XiuXianProject/GameClient/Assets/Game/HotUpdate/FairyGUI/GFGUIPackage.cs

using FairyGUI;
using System.Collections.Generic;
using UnityEngine;
using YooAsset;
using System.Threading.Tasks;

namespace GFGGame
{
    public class GFGUIPackage
    {
        private static Dictionary<string, UIPackage> _packages = new Dictionary<string, UIPackage>();

        private static Dictionary<string, List<AssetOperationHandle>> assetHandleCacheDic =
            new Dictionary<string, List<AssetOperationHandle>>();

        private static Dictionary<string, int> _assetCount = new Dictionary<string, int>();

        /// <summary>
        /// 同步加载 FairyGUI 包
        /// </summary>
        public static void AddPackage(string descFilePath)
        {
            _assetCount.TryGetValue(descFilePath, out var count);
            if (count > 0)
            {
                _assetCount[descFilePath] = count + 1;
                return;
            }

            _assetCount.Add(descFilePath, count + 1);
            var handle = YooAssets.LoadAssetSync<TextAsset>($"{descFilePath}_fui.bytes");
            TextAsset textAsset = handle.AssetObject as TextAsset;
            CacheAssetHandle(descFilePath, handle);
            var uiPackage = UIPackage.AddPackage(textAsset.bytes, descFilePath, LoadResourceSync);
            _packages.Add(descFilePath, uiPackage);
        }

        /// <summary>
        /// 异步加载 FairyGUI 包（支持 await）
        /// </summary>
        public static async Task AddPackageAsync(string descFilePath)
        {
            _assetCount.TryGetValue(descFilePath, out var count);
            if (count > 0)
            {
                _assetCount[descFilePath] = count + 1;
                return;
            }

            _assetCount.Add(descFilePath, count + 1);

            // 1. 异步加载描述文件
            var handle = YooAssets.LoadAssetAsync<TextAsset>($"{descFilePath}_fui.bytes");
            await handle.Task;
            if (handle.Status != EOperationStatus.Succeed)
                throw new System.Exception($"Failed to load package: {descFilePath}");

            // 2. 添加包
            TextAsset textAsset = handle.AssetObject as TextAsset;
            CacheAssetHandle(descFilePath, handle);
            var uiPackage = UIPackage.AddPackage(textAsset.bytes, descFilePath, LoadResourceAsync);
            _packages.Add(descFilePath, uiPackage);

            CheckRemovePackage(descFilePath);
        }

        /// <summary>
        /// 同步加载资源回调
        /// </summary>
        private static object LoadResourceSync(string name, string extension, System.Type type,
            out DestroyMethod destroyMethod)
        {
            destroyMethod = DestroyMethod.None;
            string location = name + extension;
            if (!YooAssets.CheckResExist(location))
                return null;

            var handle = YooAssets.LoadAssetSync(location, type);
            CacheAssetHandle(name, handle);
            return handle.AssetObject;
        }

        /// <summary>
        /// 异步加载资源回调
        /// </summary>
        private static void LoadResourceAsync(string name, string extension, System.Type type, PackageItem item)
        {
            string location = name + extension;
            if (!YooAssets.CheckResExist(location))
                return;

            AssetOperationHandle handle = YooAssets.LoadAssetAsync(location, type);
            CacheAssetHandle(name, handle);
            handle.Completed += (op) =>
            {
                if (op.AssetObject == null) return;

                // 处理带 Alpha 通道的纹理
                if (op.AssetObject is Texture tex)
                {
                    string alphaLocation = name + "!a" + extension;
                    if (YooAssets.CheckResExist(alphaLocation))
                    {
                        var alphaHandle = YooAssets.LoadAssetAsync(alphaLocation, type);
                        CacheAssetHandle(name, alphaHandle);
                        alphaHandle.Completed += (alphaOp) =>
                        {
                            if (alphaOp.AssetObject is Texture alphaTex)
                                item.owner.SetItemAsset(item, tex, alphaTex, DestroyMethod.None);
                        };
                        return;
                    }
                }

                item.owner.SetItemAsset(item, op.AssetObject, null, DestroyMethod.None);
            };
        }

        public static void ReleasePackage(string descFilePath)
        {
            if (_assetCount.TryGetValue(descFilePath, out var count) && count > 0)
            {
                _assetCount[descFilePath] = count - 1;
                CheckRemovePackage(descFilePath);
            }
        }

        private static void CheckRemovePackage(string descFilePath)
        {
            if (_assetCount.TryGetValue(descFilePath, out var count) && count <= 0)
            {
                if (_packages.TryGetValue(descFilePath, out var package))
                {
                    UIPackage.RemovePackage(package.name);
                    _packages.Remove(descFilePath);
                    _assetCount.Remove(descFilePath);
                }

                if (assetHandleCacheDic.TryGetValue(descFilePath, out var handles))
                {
                    foreach (var handle in handles)
                        handle.Release();
                    handles.Clear();
                }
            }
        }

        private static void CacheAssetHandle(string key, AssetOperationHandle handle)
        {
            if (!assetHandleCacheDic.TryGetValue(key, out var list))
            {
                list = new List<AssetOperationHandle>();
                assetHandleCacheDic.Add(key, list);
            }

            list.Add(handle);
        }
    }
}