shaoxiadiablo/Assets/AGame/Scripts/Proxy/Asset/AssetProxy.cs

// ***********************************************************************
// Assembly         : Unity
// Author           : Kimch
// Created          : 
//
// Last Modified By : Kimch
// Last Modified On : 
// ***********************************************************************
// <copyright file= "AssetProxy" company=""></copyright>
// <summary></summary>
// ***********************************************************************
//#if UNITY_EDITOR
//#define USE_ASSETDATABASE
//#endif
//#define USE_ASSETBUNDLE
//#define USE_RESOURCE
#define USE_ADDRESSABLES

namespace G
{
	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Threading.Tasks;
	using UnityEngine;
	using UnityEngine.AddressableAssets;
	using UnityEngine.ResourceManagement.AsyncOperations;
	using Object = UnityEngine.Object;

	#region INTERFACE

	public interface IAsyncR
	{
		/// <summary>Gets a value indicating whether this <see cref="IAsyncR"/> is done.</summary>
		bool done
		{
			get;
		}

		/// <summary>Gets the error.</summary>
		string error
		{
			get;
		}

		/// <summary>Gets or sets the progress.</summary>
		float progress
		{
			get;
		}

		/// <summary>Gets or sets the data.</summary>
		object asyncData
		{
			get;
		}

		/// <summary>Gets the asset bundle.</summary>        
		AssetBundle assetBundle
		{
			get;
		}
	}

	#endregion

	/// <summary>
	/// 
	/// </summary>
	partial class AssetProxy : F.GameProxy
	{
		private const string GLOBAL_ASSET_POOL_NAME = "global";
		private const string TEMPORARY_ASSET_POOL_NAME = "temporary";
		private const string INSTANCES_POOL_NAME = "instances";

		#region Model

		private class AsyncR : IAsyncR
		{
			#region Field

			/// <summary>
			/// 
			/// </summary>
			private float _progress;
			/// <summary>
			/// 
			/// </summary>
			private string _error;
			/// <summary>
			/// 
			/// </summary>
			private object _data;

			#endregion

			#region Property

			bool IAsyncR.done
			{
				get
				{
					return _progress > 1f;
				}
			}

			string IAsyncR.error
			{
				get
				{
					return _error;
				}
			}

			float IAsyncR.progress
			{
				get
				{
					return _progress;
				}
			}

			object IAsyncR.asyncData
			{
				get
				{
					return _data;
				}
			}

			AssetBundle IAsyncR.assetBundle
			{
				get
				{
					return _data as AssetBundle;
				}
			}

			#endregion

			#region Method

			public void AsyncProcess(float progress)
			{
				_progress = progress;
				_error = null;
				_data = null;
			}

			public void AsyncSuccess(object data)
			{
				_progress = 1.0001f;
				_error = null;
				_data = data;
			}

			public void AsyncFailure(string error)
			{
				_progress = 1.0001f;
				_error = error;
				_data = null;
			}

			#endregion
		}

		#endregion

		#region FIELD

		/// <summary>
		/// 异步加载回调
		/// </summary>
		private AsyncR _asyncR = new AsyncR();

		/// <summary>
		/// 
		/// </summary>
		private Dictionary<string, Object> _persistentAssets = new Dictionary<string, Object>(StringComparer.OrdinalIgnoreCase);
		/// <summary>
		/// 
		/// </summary>
		private Dictionary<string, Object> _temporaryAssets = new Dictionary<string, Object>(StringComparer.OrdinalIgnoreCase);

		#endregion

		#region Proxy

		/// <summary>
		/// 
		/// </summary>
		public override int priority
		{
			get { return int.MaxValue; }
		}

		/// <summary>
		/// 已经初始化
		/// </summary>
		public bool initialized
		{
			get;
			private set;
		}

		public override void Init()
		{
#if USE_ADDRESSABLES
			Addressables.InitializeAsync().Completed += (handle) =>
			{
				this.initialized = true;
				KUIBind.Bind(null, this.UIAsyncInstantiater, this.UIReleaser);
			};
#elif USE_ASSETBUNDLE
            F.KFramework.ResourceManager.InitResources((errorMsg) =>
            {
                if (string.IsNullOrEmpty(errorMsg))
                {
                    initialized = true;
                }
            });
#else
			this.initialized = true;
#endif
			CreateReleasePool(INSTANCES_POOL_NAME);
			CreateReleasePool(GLOBAL_ASSET_POOL_NAME);
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		public override Task LoadAsync()
		{
			Preload();
			return TryGetGlobalAssetsAsync<Object>("global").Task;
		}

		/// <summary>
		/// 
		/// </summary>
		public override void LoadCompleted()
		{
			//Preload();
		}

		private void SceneManager_sceneLoaded(UnityEngine.SceneManagement.Scene arg0, UnityEngine.SceneManagement.LoadSceneMode arg1)
		{
		}

		private void SceneManager_sceneUnloaded(UnityEngine.SceneManagement.Scene arg0)
		{
			RemoveReleasePool(TEMPORARY_ASSET_POOL_NAME);
			CreateReleasePool(TEMPORARY_ASSET_POOL_NAME);
			System.GC.Collect();
		}

		/// <summary>
		/// 预加载
		/// </summary>
		void Preload()
		{
			StartCoroutine(PreloadCO());
		}

		/// <summary>
		/// 
		/// </summary>
		/// <returns></returns>
		IEnumerator PreloadCO()
		{
			//yield return null;
			yield return new WaitForSeconds(0.3f);
			//Debug.Log("Preload " + Time.frameCount);
			//yield return new WaitForSecondsRealtime(5);
			var handle = TryGetGlobalAssetsAsync<UnityEngine.U2D.SpriteAtlas>("icon");
			yield return handle;
			IconProxy.Instance.LoadAtlas(handle.Result);

			//TryGetGlobalAssetAsync<GameObject>("ui_w_main");
		}

		#endregion

		#region API	

		public void CheckAndUpdateAssets(Callback2 callback)
		{
			StartCoroutine(UpdateAsync(callback));
		}

		private IEnumerator UpdateAsync(Callback2 callback)
		{
			//手动检查更新
			var checkHandle = Addressables.CheckForCatalogUpdates(false);
			PostNotification(GlobalDefine.EVENT_CHECK_ASSET, (AsyncOperationHandle)checkHandle, "检查资源更新");
			yield return checkHandle;
			if (checkHandle.Result.Count > 0)
			{
				Debug.Log("有更新的CataLogs");
				//ShowInfo("有更新的CataLog Count : " + checkHandle.Result.Count);
				var updateHandle = Addressables.UpdateCatalogs(checkHandle.Result, false);
				PostNotification(GlobalDefine.EVENT_UPDATE_ASSET, (AsyncOperationHandle)updateHandle, "更新资源目录");
				yield return updateHandle;

				var locators = updateHandle.Result;
				foreach (var locator in locators)
				{
					var sizeHandle = Addressables.GetDownloadSizeAsync(locator.Keys);
					yield return sizeHandle;
					var downloadSize = sizeHandle.Result;

					Debug.Log("下载资源大小: " + downloadSize);
					Addressables.Release(sizeHandle);

					if (downloadSize > 0)
					{
						var downloadHandle = Addressables.DownloadDependenciesAsync(locator.Keys, Addressables.MergeMode.Union);
						PostNotification(GlobalDefine.EVENT_DOWNLOAD_ASSET, downloadHandle, $"下载{locator.ToString()}");
						while (!downloadHandle.IsDone)
						{
							yield return null;
						}

						Debug.Log($"{locator.ToString()}下载完成");
						Addressables.Release(downloadHandle);
					}
				}

				Debug.Log("更新完成");
				Addressables.Release(updateHandle);
			}
			else
			{
				Debug.Log("没有要更新的内容");
			}

			Addressables.Release(checkHandle);
			callback?.Invoke(0, "");
			callback = null;
		}

		public void Repair()
		{
			Addressables.ClearResourceLocators();
			Caching.ClearCache();
		}

		/// <summary>
		/// (手动加载)
		/// </summary>
		/// <typeparam name="TObject"></typeparam>
		/// <param name="key"></param>
		/// <returns></returns>
		public AsyncOperationHandle<TObject> GetAssetAsync<TObject>(string key)
		{
			return Addressables.LoadAssetAsync<TObject>(key);
		}

		/// <summary>
		/// (手动加载)
		/// </summary>
		/// <typeparam name="TObject"></typeparam>
		/// <param name="key"></param>
		/// <returns></returns>
		public AsyncOperationHandle<IList<TObject>> GetAssetsAsync<TObject>(string key)
		{
			return Addressables.LoadAssetsAsync<TObject>(key, null);
		}

		/// <summary>
		/// (手动释放)
		/// </summary>
		/// <typeparam name="TObject"></typeparam>
		/// <param name="obj"></param>
		public void Release<TObject>(TObject obj)
		{
			Addressables.Release(obj);
		}

		/// <summary>
		/// (手动释放)
		/// </summary>
		/// <param name="handle"></param>
		public void Release(AsyncOperationHandle handle)
		{
			Addressables.Release(handle);
		}

		/// <summary>
		/// (手动释放)
		/// </summary>
		/// <typeparam name="TObject"></typeparam>
		/// <param name="handle"></param>
		public void Release<TObject>(AsyncOperationHandle<TObject> handle)
		{
			Addressables.Release(handle);
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="name"></param>
		/// <returns></returns>
		public AsyncOperationHandle<GameObject> InstantiateAsync(string name)
		{
			string key = name;// "UI/" + name + ".prefab";
			var resultT = Addressables.InstantiateAsync(key);
			return resultT;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="name"></param>
		/// <param name="parent"></param>
		/// <returns></returns>
		public AsyncOperationHandle<GameObject> InstantiateAsync(string name, Transform parent)
		{
			string key = name;// "UI/" + name + ".prefab";
			var resultT = Addressables.InstantiateAsync(key, parent);
			return resultT;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="handle"></param>
		/// <returns></returns>
		public bool ReleaseInstance(AsyncOperationHandle handle)
		{
			return Addressables.ReleaseInstance(handle);
		}
		/// <summary>
		/// 
		/// </summary>
		/// <param name="handle"></param>
		/// <returns></returns>
		public bool ReleaseInstance(AsyncOperationHandle<GameObject> handle)
		{
			return Addressables.ReleaseInstance(handle);
		}
		/// <summary>
		/// 
		/// </summary>
		/// <param name="instance"></param>
		public bool ReleaseInstance(GameObject instance)
		{
			return Addressables.ReleaseInstance(instance);
		}

		/// <summary>
		/// 使用自动释放池
		/// </summary>
		/// <typeparam name="TObject"></typeparam>
		/// <param name="key"></param>
		/// <returns></returns>
		public AsyncOperationHandle<TObject> TryGetAssetAsync<TObject>(string key, string pool)
		{
			if (TryGetHandleInReleasePool(key, out AsyncOperationHandle result, pool))
			{
				return result.Convert<TObject>();
			}
			var resultT = Addressables.LoadAssetAsync<TObject>(key);
			AddHandleToReleasePool(key, resultT, pool);
			return resultT;
		}

		/// <summary>
		/// 使用自动释放池
		/// </summary>
		/// <typeparam name="TObject"></typeparam>
		/// <param name="key"></param>
		/// <returns></returns>
		public AsyncOperationHandle<IList<TObject>> TryGetAssetsAsync<TObject>(string key, string pool)
		{
			if (TryGetHandleInReleasePool(key, out AsyncOperationHandle result, pool))
			{
				return result.Convert<IList<TObject>>();
			}
			var resultT = Addressables.LoadAssetsAsync<TObject>(key, null);
			AddHandleToReleasePool(key, resultT, pool);
			return resultT;
		}

		/// <summary>
		/// 全局(游戏关闭时释放)
		/// </summary>
		/// <typeparam name="TObject"></typeparam>
		/// <param name="key"></param>
		/// <returns></returns>
		public AsyncOperationHandle<TObject> TryGetGlobalAssetAsync<TObject>(string key)
		{
			return TryGetAssetAsync<TObject>(key, GLOBAL_ASSET_POOL_NAME);
		}

		/// <summary>
		/// 全局(游戏关闭时释放)
		/// </summary>
		/// <typeparam name="TObject"></typeparam>
		/// <param name="key"></param>
		/// <returns></returns>
		public AsyncOperationHandle<IList<TObject>> TryGetGlobalAssetsAsync<TObject>(string key)
		{
			return TryGetAssetsAsync<TObject>(key, GLOBAL_ASSET_POOL_NAME);
		}

		/// <summary>
		/// 临时(场景切换时释放)
		/// </summary>
		/// <typeparam name="TObject"></typeparam>
		/// <param name="key"></param>
		/// <returns></returns>
		public AsyncOperationHandle<TObject> TryGetTemporaryAssetAsync<TObject>(string key)
		{
			return TryGetAssetAsync<TObject>(key, TEMPORARY_ASSET_POOL_NAME);
		}

		/// <summary>
		/// 
		/// </summary>
		/// <typeparam name="TObject"></typeparam>
		/// <param name="key"></param>
		/// <returns></returns>
		public AsyncOperationHandle<IList<TObject>> TryGetTemporaryAssetsAsync<TObject>(string key)
		{
			return TryGetAssetsAsync<TObject>(key, TEMPORARY_ASSET_POOL_NAME);
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="name"></param>
		/// <returns></returns>
		public AsyncOperationHandle<GameObject> TryInstantiateAsync(string name, Transform parent)
		{
			string key = name;// "UI/" + name + ".prefab";
			if (TryGetHandleInReleasePool(key, out AsyncOperationHandle result, INSTANCES_POOL_NAME))
			{
				return result.Convert<GameObject>();
			}
			var resultT = Addressables.InstantiateAsync(key, parent);
			AddHandleToReleasePool(key, resultT, INSTANCES_POOL_NAME);
			return resultT;
		}

		/// <summary>
		/// ui框架                                                             
		/// </summary>
		/// <param name="key"></param>
		/// <param name="callback"></param>
		public void UIAsyncInstantiater(string name, Transform parent, Action<Object> callback)
		{
			string key = name;// "UI/" + name + ".prefab";

			if (TryGetHandleInReleasePool(key, out AsyncOperationHandle result, INSTANCES_POOL_NAME))
			{
				var handle = result.Convert<GameObject>();
				if (handle.Result)
					handle.Result.transform.SetParent(parent);
				callback?.Invoke(handle.Result);
				return;
			}

			var resultT = Addressables.InstantiateAsync(key, parent);
			resultT.Completed += (handle) =>
			{
				if (handle.Status == AsyncOperationStatus.Succeeded)
				{
					var instance = handle.Result;
					instance.name = System.IO.Path.GetFileNameWithoutExtension(key);
					callback?.Invoke(handle.Result);
				}
			};
			AddHandleToReleasePool(key, resultT, INSTANCES_POOL_NAME);
		}

		/// <summary>
		/// ui框架
		/// </summary>
		/// <param name="instance"></param>
		public void UIReleaser(Object instance)
		{
			RemoveHandleInReleasePool(instance.name, INSTANCES_POOL_NAME);
			Addressables.ReleaseInstance((GameObject)instance);
		}

		#endregion

		#region UNITY

		public AssetProxy()
		{
			_Instance = this;
			UnityEngine.SceneManagement.SceneManager.sceneLoaded += this.SceneManager_sceneLoaded;
			UnityEngine.SceneManagement.SceneManager.sceneUnloaded += this.SceneManager_sceneUnloaded;
			Application.lowMemory += OnLowMemoryCallback;
		}

		#endregion

		#region STATIC

		private static AssetProxy _Instance;

		public static AssetProxy Instance
		{
			get { return _Instance; }
		}

		#endregion
	}
}