YooAssetScene/Assets/YooAsset/Runtime/YooAssets.cs

using System;
using System.Diagnostics;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

namespace YooAsset
{
    public static partial class YooAssets
    {
#if UNITY_EDITOR
        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
        private static void OnRuntimeInitialize()
        {
            _isInitialize = false;
            _packages.Clear();
        }
#endif

        private static bool _isInitialize = false;
        private static GameObject _driver = null;
        private static readonly List<ResourcePackage> _packages = new List<ResourcePackage>();

        /// <summary>
        /// 是否已经初始化
        /// </summary>
        public static bool Initialized
        {
            get { return _isInitialize; }
        }

        /// <summary>
        /// 初始化资源系统
        /// </summary>
        /// <param name="logger">自定义日志处理</param>
        public static void Initialize(ILogger logger = null)
        {
            if (_isInitialize)
            {
                UnityEngine.Debug.LogWarning($"{nameof(YooAssets)} is initialized !");
                return;
            }

            if (_isInitialize == false)
            {
                YooLogger.Logger = logger;

                // 创建驱动器
                _isInitialize = true;
                _driver = new UnityEngine.GameObject($"[{nameof(YooAssets)}]");
                _driver.AddComponent<YooAssetsDriver>();
                UnityEngine.Object.DontDestroyOnLoad(_driver);
                YooLogger.Log($"{nameof(YooAssets)} initialize !");

#if DEBUG
                // 添加远程调试脚本
                _driver.AddComponent<RemoteDebuggerInRuntime>();
#endif

                // 初始化异步操作系统
                OperationSystem.Initialize();
            }
        }

        /// <summary>
        /// 销毁资源系统
        /// </summary>
        public static void Destroy()
        {
            if (_isInitialize)
            {
                _isInitialize = false;

                if (_driver != null)
                    GameObject.Destroy(_driver);

                // 销毁异步操作系统
                OperationSystem.DestroyAll();

                // 卸载所有AssetBundle
                AssetBundle.UnloadAllAssetBundles(true);

                // 清空资源包裹列表
                _packages.Clear();
            }
        }

        /// <summary>
        /// 更新资源系统
        /// </summary>
        internal static void Update()
        {
            if (_isInitialize)
            {
                OperationSystem.Update();
            }
        }

        /// <summary>
        /// 创建资源包裹
        /// </summary>
        /// <param name="packageName">包裹名称</param>
        public static ResourcePackage CreatePackage(string packageName)
        {
            return CreatePackage(packageName, 0);
        }

        /// <summary>
        /// 创建资源包裹
        /// </summary>
        /// <param name="packageName">包裹名称</param>
        /// <param name="packagePriority">包裹优先级（值越大越优先更新）</param>
        public static ResourcePackage CreatePackage(string packageName, uint packagePriority)
        {
            CheckException(packageName);
            if (ContainsPackage(packageName))
                throw new YooPackageException(packageName, $"Package {packageName} already existed ! Cannot create duplicate packages.");

            YooLogger.Log($"Create resource package : {packageName}");
            ResourcePackage package = new ResourcePackage(packageName);
            _packages.Add(package);

            // 注册包裹调度器
            OperationSystem.CreatePackageScheduler(packageName, packagePriority);

            return package;
        }

        /// <summary>
        /// 获取资源包裹
        /// </summary>
        /// <param name="packageName">包裹名称</param>
        public static ResourcePackage GetPackage(string packageName)
        {
            CheckException(packageName);
            var package = GetPackageInternal(packageName);
            if (package == null)
                YooLogger.Error($"Can not found resource package : {packageName}");
            return package;
        }

        /// <summary>
        /// 尝试获取资源包裹
        /// </summary>
        /// <param name="packageName">包裹名称</param>
        public static ResourcePackage TryGetPackage(string packageName)
        {
            CheckException(packageName);
            return GetPackageInternal(packageName);
        }

        /// <summary>
        /// 获取所有资源包裹
        /// </summary>
        public static List<ResourcePackage> GetAllPackages()
        {
            return _packages.ToList();
        }

        /// <summary>
        /// 移除资源包裹
        /// </summary>
        /// <param name="packageName">包裹名称</param>
        public static bool RemovePackage(string packageName)
        {
            CheckException(packageName);
            ResourcePackage package = GetPackageInternal(packageName);
            if (package == null)
                return false;

            return RemovePackage(package);
        }

        /// <summary>
        /// 移除资源包裹
        /// </summary>
        /// <param name="package">包裹实例对象</param>
        public static bool RemovePackage(ResourcePackage package)
        {
            CheckException(package);
            string packageName = package.PackageName;
            if (package.InitializeStatus != EOperationStatus.None)
            {
                YooLogger.Error($"The resource package {packageName} has not been destroyed, please call the method {nameof(ResourcePackage.DestroyPackageAsync)} to destroy!");
                return false;
            }

            YooLogger.Log($"Remove resource package : {packageName}");

            // 先销毁调度器，再移除包裹
            OperationSystem.DestroyPackageScheduler(packageName);

            _packages.Remove(package);
            return true;
        }

        /// <summary>
        /// 检测资源包裹是否存在
        /// </summary>
        /// <param name="packageName">包裹名称</param>
        public static bool ContainsPackage(string packageName)
        {
            CheckException(packageName);
            var package = GetPackageInternal(packageName);
            return package != null;
        }

        private static ResourcePackage GetPackageInternal(string packageName)
        {
            foreach (var package in _packages)
            {
                if (package.PackageName == packageName)
                    return package;
            }
            return null;
        }
        private static void CheckException(string packageName)
        {
            if (_isInitialize == false)
                throw new YooInitializeException($"{nameof(YooAssets)} not initialized ! Please call  {nameof(YooAssets.Initialize)} first.");

            if (string.IsNullOrEmpty(packageName))
                throw new YooInitializeException("Package name cannot be null or empty !");
        }
        private static void CheckException(ResourcePackage package)
        {
            if (_isInitialize == false)
                throw new YooInitializeException($"{nameof(YooAssets)} not initialized ! Please call  {nameof(YooAssets.Initialize)} first.");

            if (package == null)
                throw new YooInitializeException("Package instance cannot be null !");
        }

        #region 系统参数
        /// <summary>
        /// 设置异步系统参数，每帧执行消耗的最大时间切片（单位：毫秒）
        /// </summary>
        public static void SetOperationSystemMaxTimeSlice(long milliseconds)
        {
            OperationSystem.MaxTimeSlice = milliseconds;
        }
        #endregion

        #region 调试信息
        internal static DebugReport GetDebugReport()
        {
            DebugReport report = new DebugReport();
            report.FrameCount = Time.frameCount;

            foreach (var package in _packages)
            {
                var packageData = package.GetDebugPackageData();
                report.PackageDatas.Add(packageData);
            }
            return report;
        }
        #endregion
    }
}