path: root/Client/Assets/Scripts/XUtliPoolLib/AssetBundleInfo.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using XUpdater;

namespace XUtliPoolLib
{
	public class AssetBundleInfo
	{
		[SerializeField]
		public int refCount { get; private set; }

		public bool isUnused
		{
			get
			{
				return this._isReady && Time.time - this._readyTime > this.minLifeTime && this.refCount <= 0 && this.UpdateReference() == 0;
			}
		}

		public bool isReady
		{
			get
			{
				return this._isReady;
			}
			set
			{
				this._isReady = value;
			}
		}

		public virtual UnityEngine.Object mainObject
		{
			get
			{
				bool flag = this._mainObject == null && this._isReady;
				if (flag)
				{
					this._mainObject = this.bundle.LoadAsset(this.bundle.GetAllAssetNames()[0]);
					bool flag2 = this._mainObject != null;
					if (flag2)
					{
						bool flag3 = this.data.compositeType == AssetBundleExportType.Root;
						if (flag3)
						{
							bool flag4 = XSingleton<XUpdater.XUpdater>.singleton.ABManager != null;
							if (flag4)
							{
								XSingleton<XUpdater.XUpdater>.singleton.ABManager.AddUnloadBundleQueue(this);
							}
						}
					}
				}
				return this._mainObject;
			}
		}

		public AssetBundleInfo.OnUnloadedHandler onUnloaded;

		internal AssetBundle bundle;

		public uint bundleName;

		public AssetBundleData data;

		public float minLifeTime = 2f;

		private float _readyTime;

		private bool _isReady;

		private UnityEngine.Object _mainObject;

		private HashSet<AssetBundleInfo> deps = null;

		private List<uint> depChildren = null;

		private List<WeakReference> references = new List<WeakReference>();

		public delegate void OnUnloadedHandler(AssetBundleInfo abi);

		public void AddDependency(AssetBundleInfo target)
		{
			bool flag = target != null;
			if (flag)
			{
				bool flag2 = this.deps == null;
				if (flag2)
				{
					this.deps = new HashSet<AssetBundleInfo>();
				}
				bool flag3 = this.deps.Add(target);
				if (flag3)
				{
					target.Retain();
					bool flag4 = target.depChildren == null;
					if (flag4)
					{
						target.depChildren = new List<uint>();
					}
					target.depChildren.Add(this.bundleName);
				}
			}
		}

		public void ResetLifeTime()
		{
			bool isReady = this._isReady;
			if (isReady)
			{
				this._readyTime = Time.time;
			}
		}

		public void Retain()
		{
			int refCount = this.refCount;
			this.refCount = refCount + 1;
		}

		public void Release()
		{
			int refCount = this.refCount;
			this.refCount = refCount - 1;
		}

		public void Retain(UnityEngine.Object owner)
		{
			bool flag = owner == null;
			if (flag)
			{
				throw new Exception("Please set the user!");
			}
			for (int i = 0; i < this.references.Count; i++)
			{
				bool flag2 = owner.Equals(this.references[i].Target);
				if (flag2)
				{
					return;
				}
			}
			WeakReference item = new WeakReference(owner);
			this.references.Add(item);
		}

		public void Release(object owner)
		{
			for (int i = 0; i < this.references.Count; i++)
			{
				bool flag = this.references[i].Target == owner;
				if (flag)
				{
					this.references.RemoveAt(i);
					break;
				}
			}
		}

		public virtual GameObject Instantiate()
		{
			return this.Instantiate(true);
		}

		public virtual GameObject Instantiate(bool enable)
		{
			bool flag = this.mainObject != null;
			if (flag)
			{
				bool flag2 = this.mainObject is GameObject;
				if (flag2)
				{
					GameObject gameObject = this.mainObject as GameObject;
					gameObject.SetActive(enable);
					GameObject gameObject2 = XCommon.Instantiate<GameObject>(gameObject);
					gameObject2.name = gameObject.name;
					this.Retain(gameObject2);
					return gameObject2;
				}
			}
			return null;
		}

		public virtual GameObject Instantiate(Vector3 position, Quaternion rotation, bool enable = true)
		{
			bool flag = this.mainObject != null;
			if (flag)
			{
				bool flag2 = this.mainObject is GameObject;
				if (flag2)
				{
					GameObject gameObject = this.mainObject as GameObject;
					gameObject.SetActive(enable);
					GameObject gameObject2 = UnityEngine.Object.Instantiate<GameObject>(gameObject, position, rotation, null);
					gameObject2.name = gameObject.name;
					this.Retain(gameObject2);
					return gameObject2;
				}
			}
			return null;
		}

		public UnityEngine.Object Require(UnityEngine.Object user)
		{
			this.Retain(user);
			return this.mainObject;
		}

		public UnityEngine.Object Require(Component c, bool autoBindGameObject)
		{
			bool flag = autoBindGameObject && c && c.gameObject;
			UnityEngine.Object result;
			if (flag)
			{
				result = this.Require(c.gameObject);
			}
			else
			{
				result = this.Require(c);
			}
			return result;
		}

		private int UpdateReference()
		{
			for (int i = 0; i < this.references.Count; i++)
			{
				UnityEngine.Object @object = (UnityEngine.Object)this.references[i].Target;
				bool flag = !@object;
				if (flag)
				{
					this.references.RemoveAt(i);
					i--;
				}
			}
			return this.references.Count;
		}

		public virtual void Dispose()
		{
			this.UnloadBundle();
			bool flag = this.deps != null;
			if (flag)
			{
				foreach (AssetBundleInfo assetBundleInfo in this.deps)
				{
					bool flag2 = assetBundleInfo.depChildren != null;
					if (flag2)
					{
						assetBundleInfo.depChildren.Remove(this.bundleName);
					}
					assetBundleInfo.Release();
				}
				this.deps.Clear();
			}
			this.references.Clear();
			bool flag3 = this.onUnloaded != null;
			if (flag3)
			{
				this.onUnloaded(this);
			}
			bool flag4 = !(this._mainObject is GameObject) && !(this._mainObject is ScriptableObject) && !(this._mainObject is Material);
			if (flag4)
			{
				Resources.UnloadAsset(this._mainObject);
			}
			else
			{
				UnityEngine.Object.Destroy(this._mainObject);
			}
			this._mainObject = null;
		}

		public AsyncOperation LoadAsync(string name, Type t)
		{
			bool flag = this._mainObject == null && this._isReady;
			AsyncOperation result;
			if (flag)
			{
				result = this.bundle.LoadAssetAsync(name, t);
			}
			else
			{
				result = null;
			}
			return result;
		}

		public void AsyncLoadFinish(UnityEngine.Object asset)
		{
			bool flag = this._mainObject == null && this._isReady;
			if (flag)
			{
				this.Release();
				this._mainObject = asset;
				bool flag2 = this.data.compositeType == AssetBundleExportType.Root;
				if (flag2)
				{
					bool flag3 = XSingleton<XUpdater.XUpdater>.singleton.ABManager != null;
					if (flag3)
					{
						XSingleton<XUpdater.XUpdater>.singleton.ABManager.AddUnloadBundleQueue(this);
					}
				}
			}
		}

		private T LoadAsset<T>(string name) where T : UnityEngine.Object
		{
			return this.bundle.LoadAsset(name, typeof(T)) as T;
		}

		public void UnloadBundle()
		{
			bool flag = this.bundle != null;
			if (flag)
			{
				bool enableLog = AssetBundleManager.enableLog;
				if (enableLog)
				{
					XSingleton<XDebug>.singleton.AddLog((string.Concat(new object[]
					{
						"Unload : ",
						this.data.compositeType,
						" >> ",
						this.bundleName,
						"(",
						this.data.debugName
					}) != null) ? this.data.debugName : ")", null, null, null, null, null, XDebugColor.XDebug_None);
				}
				this.bundle.Unload(false);
				bool flag2 = XSingleton<XUpdater.XUpdater>.singleton.ABManager != null;
				if (flag2)
				{
					XSingleton<XUpdater.XUpdater>.singleton.ABManager.DeleteBundleCount();
				}
			}
			this.bundle = null;
		}
	}
}