Unity之可寻址资源之初始化，下载

以下代码实现了Addressable Assets的初始化，登陆时下载，静默下载，如下：

using ClientData;
using Common;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.ResourceManagement.ResourceLocations;
using UnityEngine.ResourceManagement.ResourceProviders;

namespace FashionBeat
{
    public class AddressableABManager : GameBehaviour
    {
        public static int
            MaxLoginDownloadingThread = 10,
            MinHotPatchMB = 10;
        public static float
            ProgressBarSpeed = 0.05f;
        public static bool
            //IsOpenLoginDownload = true,
            IsOpenQuietlyDownload = true;

        const string
            DefaultRampName = "model_ramp_default",
            LoginDownloadKeysFile = "Address/t_download_login",
            QuietlyDownloadKeysFile = "Address/t_download_quietly";

        const float SizeScale = 1f / 1024 / 1024;
        static readonly StringBuilder s_sb = new StringBuilder();

        string m_mainABFolder, m_localABFolder;
        float m_loginDownloadedMB, m_timerLoginDownloading, m_quietlyDownloadedMB, m_timerQuietlyDownloading;
        Queue<object> m_loginDownloadKeys, m_quietlyDownloadKeys;
        List<object> m_loginDownloadingKeys;
        float m_completeProgressWhenInit;

        // Singleton
        static AddressableABManager s_singleton;
        public static AddressableABManager Singleton
        {
            get
            {
                if (!s_singleton)
                {
                    GameObject go = new GameObject(typeof(AddressableABManager).ToString());
                    go.transform.parent = GameApp.Singleton.transform;
                    s_singleton = go.AddComponent<AddressableABManager>();
                }
                return s_singleton;
            }
        }


        public enum Stage
        {
            None,
            Initializing,
            Initialized,

            StartLoginDownload,
            LoginDownloading,
            LoginDownloaded,

            QuietlyDownloading,
            QuietlyDownloadPause,
            QuietlyDownloaded,
        }


        #region Property

        static string PlatformFolder
        {
            get
            {
#if UNITY_IPHONE
                return "iOS";
#else
                return "Android";
#endif
            }
        }

        public Texture DefaultRamp { get; private set; }
        public float PercentComplete { get; private set; }
        public Stage CurStage { get; private set; }
        public string Messenge { get; private set; }


        // 登陆时下载
        public float LoginNeedDownloadMB { get; private set; }
        public float LoginDownloadedMB { get; private set; }
        public static bool IsOpenLoginDownload => Analysis.AnalysisManager.IsOpenLoginDownload();
        public bool LoginNeedHotPatch => IsOpenLoginDownload && LoginNeedDownloadMB > MinHotPatchMB;
        public float LoginDownloadSpeedMB { get; private set; }
        public float LoginDownloadedSeconds => m_timerLoginDownloading;
        public float LoginDownloadLeftSeconds { get; private set; }


        // 静默下载
        public bool NeedQuietlyDownload => IsOpenQuietlyDownload && m_quietlyDownloadKeys != null && m_quietlyDownloadKeys.Count > 0 && QuietlyNeedDownloadMB > 0;
        public float QuietlyNeedDownloadMB { get; private set; }
        public float QuietlyDownloadedMB { get; private set; }
        public float QuietlyDownloadSpeedMB { get; private set; }

        #endregion


        void Awake()
        {
            PercentComplete = 0;
            LoginNeedDownloadMB = 0;
            CurStage = Stage.None;
            m_completeProgressWhenInit = 0;
        }


        #region 初始化

        public void Init(string mainCatalogName)
        {
            IEnumerator etor = InitAsync(mainCatalogName);
            GameApp.Singleton.GameMain.StartCoroutine(etor);
        }

        IEnumerator InitAsync(string mainCatalogName)
        {
            CurStage = Stage.Initializing;
            PercentComplete = 0;
            LoginNeedDownloadMB = 0;
            QuietlyNeedDownloadMB = 0;

            string ftpServer = PackageConfig.Singleton.Config.f_ftpServer;
            string platform = PlatformFolder;
            string versionDay = PackageConfig.Singleton.VersionDay;
            string catalogRootPath = $"{ftpServer}/{versionDay}/{platform}";
            m_mainABFolder = $"{catalogRootPath}/Main/";
            m_localABFolder = $"{Addressables.RuntimePath}/{platform}/";
            string mainCatalogPath = m_mainABFolder + mainCatalogName;

            Debug.Log("ftp ab url: " + m_mainABFolder);
            Debug.Log("local ab url: " + m_localABFolder);

            // 第一次装游戏尝试从包里解压 catalog 文件
            Messenge = Localization.Get("正在尝试从包中解压资源列表");
            yield return null;
            TryCompressLocalCatalog(mainCatalogName);
            yield return new WaitForEndOfFrame();

            // 等待初始化完毕，否则无法热更
            Messenge = Localization.Get("正在初始化资源管理器");
            yield return Addressables.InitializeAsync();

            // url 重定向
            Addressables.InternalIdTransformFunc = RedirectUrl;

            // 初始化热更
            if (Config_t_fb_game_config.Singleton.IsOpenHotPatch)
            {
                var etor = InitHotpatchAsync(mainCatalogPath);
                while (etor.MoveNext())
                    yield return null;
            }

            Messenge = Localization.Get("初始化完成");
            PercentComplete = 1;
            yield return null;
            CurStage = Stage.Initialized;
            OnInitFinished();
        }

        IEnumerator InitHotpatchAsync(string mainCatalogPath)
        {
            Addressables.ClearResourceLocators();

            // 加载 main catalog
            Messenge = Localization.Get("正在加载资源列表");
            m_completeProgressWhenInit = 0.9f;
            yield return null;

            var handle_main = Addressables.LoadContentCatalogAsync(mainCatalogPath, true);
            Debug.Log("Start load catalog: " + mainCatalogPath);
            while (!handle_main.IsDone)
            {
                //PercentComplete = m_completeProgressWhenInit + handle_main.PercentComplete * 0.2f;
                yield return null;
            }
            PercentComplete = m_completeProgressWhenInit;
            Debug.Log("Load catalog finished: " + mainCatalogPath);
            UserDataAnalyze.TryMark(UserDataAnalyze.ActionType.LoadCatalog_Main);

            // 检查资源更新
            Messenge = Localization.Get("正在检查哪些资源需要更新");
            m_completeProgressWhenInit = 1f;
            yield return null;

            var reqLoginDownloadList = Resources.LoadAsync<TextAsset>(LoginDownloadKeysFile);
            while (reqLoginDownloadList.isDone)
                yield return null;
            var reqQuietlyDownloadList = Resources.LoadAsync<TextAsset>(QuietlyDownloadKeysFile);
            while (reqQuietlyDownloadList.isDone)
                yield return null;

            GetDownloadKeys(reqLoginDownloadList.asset, reqQuietlyDownloadList.asset);

            // 计算资源大小
            Messenge = Localization.Get("正在计算需要更新的资源的大小");
            yield return null;

            if (m_loginDownloadKeys.Count > 0)
            {
                var handleSize = Addressables.GetDownloadSizeAsync(m_loginDownloadKeys);
                while (!handleSize.IsDone)
                {
                    PercentComplete = 0.95f + handleSize.PercentComplete * 0.05f;
                    yield return null;
                }
                LoginNeedDownloadMB = handleSize.Result * SizeScale;
                Addressables.Release(handleSize);
                Debug.Log($"Need login download: {LoginNeedDownloadMB}MB, count: {m_loginDownloadKeys.Count}");
            }

            if (m_quietlyDownloadKeys.Count > 0)
            {
                var handleSize = Addressables.GetDownloadSizeAsync(m_quietlyDownloadKeys);
                while (!handleSize.IsDone)
                    yield return null;
                QuietlyNeedDownloadMB = handleSize.Result * SizeScale;
                Addressables.Release(handleSize);
                Debug.Log($"Need quietly download: {QuietlyNeedDownloadMB}MB, count: {m_quietlyDownloadKeys.Count}");
            }
        }

        void TryCompressLocalCatalog(string mainCatalogName)
        {
            string catalogCacheFolder = $"{Application.persistentDataPath}/com.unity.addressables/";
            string catalogCachePath_json = $"{catalogCacheFolder}{mainCatalogName}";
            string catalogCachePath_hash = catalogCachePath_json.Replace(".json", ".hash");

            if (File.Exists(catalogCachePath_json) && File.Exists(catalogCachePath_hash))
                return;

            if (!Directory.Exists(catalogCacheFolder))
                Directory.CreateDirectory(catalogCacheFolder);

            TextAsset taJson = Resources.Load<TextAsset>("Address/json");
            TextAsset taHash = Resources.Load<TextAsset>("Address/hash");
            File.WriteAllText(catalogCachePath_json, taJson.text);
            File.WriteAllText(catalogCachePath_hash, taHash.text);
        }

        void GetDownloadKeys(UnityEngine.Object loginDownloadList, UnityEngine.Object quietlyDownloadList)
        {
            m_loginDownloadKeys = new Queue<object>();
            TextAsset loginDownloadListTA = loginDownloadList as TextAsset;
            if (loginDownloadListTA != null)
            {
                string[] loginDownloadAssets = loginDownloadListTA.text.Split(new char[] { '
', '
' }, StringSplitOptions.RemoveEmptyEntries);
                for (int i = 0; i < loginDownloadAssets.Length; i++)
                    m_loginDownloadKeys.Enqueue(loginDownloadAssets[i]);
            }

            m_quietlyDownloadKeys = new Queue<object>();
            TextAsset quietlyDownloadListTA = quietlyDownloadList as TextAsset;
            if (quietlyDownloadListTA != null)
            {
                string[] quietlyDownloadAssets = quietlyDownloadListTA.text.Split(new char[] { '
', '
' }, StringSplitOptions.RemoveEmptyEntries);
                for (int i = 0; i < quietlyDownloadAssets.Length; i++)
                    m_quietlyDownloadKeys.Enqueue(quietlyDownloadAssets[i]);
            }
        }


        // 重定向ab包地址
        string RedirectUrl(IResourceLocation loc)
        {
            string oldUrl = loc.InternalId.Replace("\", "/");
            if (!(loc.Data is AssetBundleRequestOptions))
                return oldUrl;

            string abFolderPath = Path.GetDirectoryName(oldUrl);
            string abFolderName = Path.GetFileNameWithoutExtension(abFolderPath);
            string abFolder = abFolderName switch
            {
                "Main" => m_mainABFolder,
                _ => m_localABFolder,
            };

            if (abFolder == null)
            {
                return oldUrl;
            }

            string abName = Path.GetFileName(oldUrl);
            s_sb.Length = 0;
            s_sb.Append(abFolder);
            s_sb.Append(abName);
            return s_sb.ToString();
            //Debug.Log($"oldUrl: {oldUrl}, new url: {newUrl}, abFolder: {abFolder}, ab name: {abName}, abFolderName: {abFolderName}");
        }

        void OnInitFinished()
        {
            // 加载默认 ramp
            var assetRamp = new ImageAssetItem(ImageAssetHelp.Subfolder_Ramp, DefaultRampName);
            assetRamp.Load(() =>
            {
                DefaultRamp = assetRamp.TexObject;
            });

            // 加载粒子图集
            //ParticleAtlasLoader.Initialize();
        }

        #endregion


        #region 登陆时下载

        public void LoginDownload(Action onFinished)
        {
            if (!LoginNeedHotPatch)
                return;

            CurStage = Stage.StartLoginDownload;
            PercentComplete = 0;
            m_loginDownloadedMB = 0;
            m_loginDownloadingKeys = new List<object>();
            LoginDownloadedMB = 0;
            m_timerLoginDownloading = 0;

            for (int i = 0; i < MaxLoginDownloadingThread; i++)
            {
                StartCoroutine(LoginDownloadAsync(onFinished));
            }
        }

        void Update()
        {
            if (CurStage == Stage.StartLoginDownload)
            {
                if (LoginDownloadedMB > 0)
                    CurStage = Stage.LoginDownloading;
            }
            else if (CurStage == Stage.LoginDownloading)
            {
                m_timerLoginDownloading += Time.deltaTime;
                LoginDownloadSpeedMB = LoginDownloadedMB / m_timerLoginDownloading;
                LoginDownloadLeftSeconds = (LoginNeedDownloadMB - LoginDownloadedMB) / LoginDownloadSpeedMB;
            }
            else if (CurStage == Stage.Initializing)
            {
                if (PercentComplete < m_completeProgressWhenInit)
                {
                    PercentComplete += Time.deltaTime * ProgressBarSpeed;
                }
                if (PercentComplete > 1)
                {
                    PercentComplete = 1;
                }
            }
            else if (CurStage == Stage.QuietlyDownloading)
            {
                m_timerQuietlyDownloading += Time.deltaTime;
                QuietlyDownloadSpeedMB = QuietlyDownloadedMB / m_timerQuietlyDownloading;
            }
        }

        IEnumerator LoginDownloadAsync(Action onFinished)
        {
            while (m_loginDownloadKeys.Count > 0)
            {
                object key = m_loginDownloadKeys.Dequeue();
                // 获取下载大小
                var handleSize = Addressables.GetDownloadSizeAsync(key);
                yield return handleSize;
                float sizeMB = handleSize.Result * SizeScale;
                Addressables.Release(handleSize);

                if (sizeMB == 0)
                    continue;

                // 开始下载
                AsyncOperationHandle handleDownload = Addressables.DownloadDependenciesAsync(key, false);
                m_loginDownloadingKeys.Add(key);
                // 下载中
                while (!handleDownload.IsDone)
                {
                    LoginDownloadedMB = m_loginDownloadedMB + handleDownload.PercentComplete * sizeMB;
                    PercentComplete = Mathf.Clamp01(LoginDownloadedMB / LoginNeedDownloadMB);
                    yield return null;
                }

                // 下载完成
                m_loginDownloadingKeys.Remove(key);
                m_loginDownloadedMB += sizeMB;
                //Debug.Log($"Download finished, key: {key}, status: {handleDownload.Status}, size: {sizeMB}mb");
                Addressables.Release(handleDownload);
            }

            if (m_loginDownloadingKeys.Count > 0)
                yield break;

            // 所有资源下载完毕
            m_loginDownloadingKeys = null;
            PercentComplete = 1;
            CurStage = Stage.LoginDownloaded;
            LoginDownloadedMB = LoginNeedDownloadMB;
            if (onFinished != null)
                onFinished();
        }

        #endregion


        #region 静默下载

        void QuietlyDownload()
        {
            if (!NeedQuietlyDownload)
                return;

            CurStage = Stage.QuietlyDownloading;
            PercentComplete = 0;
            m_quietlyDownloadedMB = 0;
            QuietlyDownloadedMB = 0;
            m_timerQuietlyDownloading = 0;
            StartCoroutine(QuietlyDownloadAsync());

            Debug.Log($"Start quietly download, size: {QuietlyNeedDownloadMB} MB");
        }

        IEnumerator QuietlyDownloadAsync()
        {
            while (m_quietlyDownloadKeys.Count > 0)
            {
                while (CurStage == Stage.QuietlyDownloadPause)
                    yield return null;

                object key = m_quietlyDownloadKeys.Dequeue();
                // 获取下载大小
                var handleSize = Addressables.GetDownloadSizeAsync(key);
                yield return handleSize;
                float sizeMB = handleSize.Result * SizeScale;
                Addressables.Release(handleSize);

                if (sizeMB == 0)
                    continue;

                // 开始下载
                AsyncOperationHandle handleDownload = Addressables.DownloadDependenciesAsync(key, false);
                // 下载中
                while (!handleDownload.IsDone)
                {
                    QuietlyDownloadedMB = m_quietlyDownloadedMB + handleDownload.PercentComplete * sizeMB;
                    PercentComplete = Mathf.Clamp01(QuietlyDownloadedMB / QuietlyNeedDownloadMB);
                    yield return null;
                }

                // 下载完成
                m_quietlyDownloadedMB += sizeMB;
                //Debug.Log($"Download finished, key: {key}, status: {handleDownload.Status}, size: {sizeMB}MB, progress: {QuietlyDownloadedMB}MB / {QuietlyNeedDownloadMB}MB");
                Addressables.Release(handleDownload);
            }

            // 所有资源下载完毕
            PercentComplete = 1;
            CurStage = Stage.QuietlyDownloaded;
            QuietlyDownloadedMB = QuietlyNeedDownloadMB;
        }

        public void ToggleQuietlyDownload(bool isOpen)
        {
            if (isOpen)
            {
                if (CurStage == Stage.QuietlyDownloadPause)
                {
                    CurStage = Stage.QuietlyDownloading;
                    return;
                }

                if (CurStage == Stage.QuietlyDownloading)
                    return;
                if (!NeedQuietlyDownload)
                    return;
                QuietlyDownload();
            }
            else
            {
                if (CurStage == Stage.QuietlyDownloading)
                {
                    CurStage = Stage.QuietlyDownloadPause;
                    Debug.Log("Stop quietly download");
                }
            }
        }

        // 尝试静默下载
        public void TryOpenQuietlyDownload()
        {
            if (ClientSetting.Singleton.IsOpenQuietlyDownload)
                ToggleQuietlyDownload(true);
        }


        #endregion


        public void ClearCache()
        {
            Caching.ClearCache();
            GameApp.QuitGame();
        }
    }
}

热更导演类：

using Modules.UI;

namespace FashionBeat
{
    public class Director_HotPatching : DirectorBase
    {
        DirectorBase m_nextDir;
        string m_strTips;


        public override void Enter()
        {
            base.Enter();

            if (!Config_t_fb_game_config.Singleton.IsOpenHotPatch)
            {
                GoLogin();
                return;
            }

            if (AddressableABManager.Singleton.LoginNeedHotPatch)
            {
                float size = AddressableABManager.Singleton.LoginNeedDownloadMB;
                string msg = string.Format(Localization.Get("发现新版本，立即更新
资源大小：") + "{0:f2}MB", size);

                UI_BeforeLoginWnd.Singleton.Tips = Localization.Get("初始化完成");
                UI_BeforeLoginWnd.Singleton.ShowMsgBox(msg, StartDownload);
            }
            else
            {
                UI_BeforeLoginWnd.Singleton.Tips = Localization.Get("已经是最新版本！");
                UI_BeforeLoginWnd.Singleton.HideMsgBox();
                GoLogin();
            }
        }

        void StartDownload()
        {
            AddressableABManager.Singleton.LoginDownload(OnDownloaded);
            Analysis.AnalysisManager.TrackCommonEvent(Analysis.AnalysisEventType.BEGIN_DOWNLOAD);

            Director_Login.TryLoadNotice();
        }

        void OnDownloaded()
        {
            UI_BeforeLoginWnd.Singleton.Tips = Localization.Get("下载完成");
            GoLogin();
            Analysis.AnalysisManager.TrackCommonEvent(Analysis.AnalysisEventType.DOWNLOAD_SUCCESS);
        }

        void GoLogin()
        {
            m_nextDir = new Director_Login();
        }

        public override DirectorBase Update()
        {
            if (AddressableABManager.Singleton.CurStage == AddressableABManager.Stage.StartLoginDownload)
            {
                UI_BeforeLoginWnd.Singleton.Tips = Localization.Get("正在扫描资源");
                UI_BeforeLoginWnd.Singleton.BarValue = 0;
            }
            else if (AddressableABManager.Singleton.CurStage == AddressableABManager.Stage.LoginDownloading)
            {
                float downloadedSize = AddressableABManager.Singleton.LoginDownloadedMB;
                float needDownloadedSize = AddressableABManager.Singleton.LoginNeedDownloadMB;
                float downloadSpeed = AddressableABManager.Singleton.LoginDownloadSpeedMB;
                float downadedSeconds = AddressableABManager.Singleton.LoginDownloadedSeconds;
                float leftSeconds = AddressableABManager.Singleton.LoginDownloadLeftSeconds;

                if (m_strTips == null)
                {
                    m_strTips = Localization.Get("正在下载：");
                    m_strTips += "{0:f2}MB / {1:f2}MB";
                    m_strTips += "        " + Localization.Get("速率：");
                    m_strTips += "{2:f2}MB/S";
                    m_strTips += "        " + Localization.Get("下载时长：");
                    m_strTips += "{3:f0}S";
                    m_strTips += "        " + Localization.Get("预计剩余：");
                    m_strTips += "{4:f0}S";
                }

                UI_BeforeLoginWnd.Singleton.Tips = string.Format(m_strTips,
                    downloadedSize, needDownloadedSize, downloadSpeed, downadedSeconds, leftSeconds);
                UI_BeforeLoginWnd.Singleton.BarValue = AddressableABManager.Singleton.PercentComplete;
            }

            return m_nextDir ?? this;
        }

        public override void Exit()
        {
            base.Exit();
            m_strTips = null;
        }

    }
}

下载界面：

using FashionBeat;
using System;
using UnityEngine;

namespace Modules.UI
{
    // [fb]
    public class UI_BeforeLoginWnd : MonoBehaviour
    {
        static UI_BeforeLoginWnd s_singleton;


        [SerializeField]
        UISlider m_slider;
        [SerializeField]
        UILabel m_labelTips;
        [SerializeField]
        UILabel m_labelProgress;

        [SerializeField]
        GameObject m_goMsgBox;
        [SerializeField]
        UILabel m_labelMsgText;
        [SerializeField]
        GameObject m_buttonMsgOK;
        [SerializeField]
        Transform m_FB;


        public static UI_BeforeLoginWnd Singleton
        {
            get
            {
                if (!s_singleton)
                {
                    var asset = Resources.Load("Prefabs/Windows/ui_before_login");
                    Transform parent = FBUIRoot.Singleton.transform;
                    GameObject obj = (GameObject)Instantiate(asset, parent);
                    obj.transform.localScale = Vector3.one;
                    obj.transform.localPosition = Vector3.zero;
                    s_singleton = obj.GetComponent<UI_BeforeLoginWnd>();
                }
                return s_singleton;
            }
        }

        public static bool IsShowing => s_singleton;



        public float BarValue
        {
            set
            {
                m_slider.value = value;
                m_labelProgress.text = value.ToString("p2");
                m_slider.gameObject.SetActive(value > 0);
                m_labelProgress.gameObject.SetActive(value > 0);
            }
        }

        public string Tips
        {
            set
            {
                bool hasValue = !string.IsNullOrEmpty(value);
                m_labelTips.gameObject.SetActive(hasValue);
                if (hasValue)
                    m_labelTips.text = value;
            }
        }


        public static UI_BeforeLoginWnd Create()
        {
            return Singleton;
        }

        public static void Destroy()
        {
            if (s_singleton)
            {
                Destroy(s_singleton.gameObject);
                s_singleton = null;
            }
        }

        public static void OnlyShowBg()
        {
            Singleton.BarValue = 0;
            Singleton.Tips = null;
            Singleton.HideMsgBox();
        }


        void Awake()
        {
            s_singleton = this;

            Tips = "Tip: Initializing...";
            BarValue = 0;
            HideMsgBox();

            InitFBScreenScale();
        }

        void OnDestroy()
        {
            s_singleton = null;
        }

        public void ShowMsgBox(string text, Action onClick)
        {
            m_goMsgBox.SetActive(true);
            m_labelMsgText.text = text;
            UIEventListener.Get(m_buttonMsgOK).onClick = go =>
            {
                HideMsgBox();
                if (onClick != null)
                    onClick();
            };
        }

        public void HideMsgBox()
        {
            m_goMsgBox.SetActive(false);
        }

        private void InitFBScreenScale()
        {
            Vector2 v = FBUIRoot.Singleton.NGUISize;
            if (v.x / v.y > FBUIRoot.DefaultWidth / FBUIRoot.DefaultHeight)
            {
                return;
            }

            float t = v.y / FBUIRoot.DefaultHeight;
            m_FB.localScale = new Vector3(t, t, 1);
        }

    }
}

转载请注明出处：https://www.cnblogs.com/jietian331/p/15412258.html