JJBB/Assets/Project/Script/GameLogic/GameManager/LoadAssetBundle.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using AssetManagement;
using AssetUpdate;
using GCGame.Table;
using Module.Log;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using System.Linq;
using Object = UnityEngine.Object;
#if UNITY_EDITOR
using UnityEditor;
using System.Runtime.Serialization.Formatters.Binary;
#endif

public class LoadAssetBundle : MonoBehaviour
{
    #region Load Asset - 加载资源包的主体

    public const string atlasPathConvertTable = "AtlasPathConvert";

    public const string BUNDLE_MAIN_BASE_UI = "MainBase";
    public const string BUNDLE_PATH_MODEL   = "model/";
    public const string BUNDLE_PATH_PET     = "model/";
    public const string BUNDLE_PATH_EFFECT  = "effect/";
    public const string BUNDLE_PATH_UI      = "ui/";
    public const string BUNDLE_PATH_SOUND   = "sounds/";
    public const string BUNDLE_PATH_SPRITE  = "ui/sprite/commonitem";
    public const string BUNDLE_PATH_Other   = "other/";
    public const string bundleFileExtension = AssetConst.bundleVariant;

    public const string BUNDLE_PATH_GAMERES = "gameres";

    // 无用的Bundle，仅仅用于打包时，让Unity可以正常收集Shader之类的资源引用
    public const string BUNDLE_PATH_DUMMY = "dummy";

    // CommonItem的Bundle名称 - 原位于Editor程序集ClassifyBundles
    public const string uiCommonSpriteBundle = uiSpriteBundleHeader + "commonitem";

    // Sprite类Bundle名称头 - 原位于Editor程序集ClassifyBundles
    public const string uiSpriteBundleHeader = "ui/sprite/";

    private readonly LoadAssetRequestList<GameObject> _gameObjectList = new LoadAssetRequestList<GameObject>();
    private readonly LoadAssetRequestList<Object>     _assetList      = new LoadAssetRequestList<Object>();
    private readonly LoadAssetRequestList<AudioClip>  _audioList      = new LoadAssetRequestList<AudioClip>();
    private readonly LoadAssetRequestList<TextAsset>  _textAssetList  = new LoadAssetRequestList<TextAsset>();

    private readonly LoadSpriteRequestList   _spriteList   = new LoadSpriteRequestList();
    private readonly LoadRawImageRequestList _rawImageList = new LoadRawImageRequestList();

    public AssetPathHub pathHub { get; private set; }

    // Use this for initialization
    private void Awake()
    {
        Instance = this;
        if (!AssetUpdateManager.useResources)
        {
            // 暂时不考虑动态切换资源路径的流程，需要再处理类型情况
            pathHub = new AssetPathHub();
            // 加载全部资源资料
            string uri;
            if (string.IsNullOrEmpty(AssetUpdateManager.assetUri))
            {
                Debug.LogError("Cannot find assetInfo. You should start the game from AssetUpdate instead of Login!");
                // 这个问题无法正确恢复，仅仅测试版本可以继续使用本地资源
                uri = string.Empty;
            }
            else
            {
                uri = AssetUpdateManager.assetUri;
            }

            var dependencyPath =
                AssetConst.persistentDataPath.Open(AssetUtils.GetTextMd5(AssetConst.versionFile) +
                                                   AssetConst.bundleVariant);
            AssetDependencyInfo dependencyInfo = null;
            if (!File.Exists(dependencyPath))
            {
                Debug.LogError(
                               "Cannot find dependency file. You should start the game from AssetUpdate instead of Login!");
            }
            else
                dependencyInfo = AssetDependencyInfo.Create(dependencyPath);
            Debug.Log("LoaderAssetsBundle");
            if (dependencyInfo == null)
            {
                Debug.LogError("Unable to load dependency file! This is not recoverable!");
                LiteConfirmWin.Open("资源错误", "无法加载资源依赖！\n需要重启游戏修复！",
                                    new LiteConfirmButtonData("确定", () => SdkControl.instance.CloseGame()));
            }
            else
            {
                pathHub.Init(uri, dependencyInfo);
                var loadHub = new BundleLoadHub();
                // 暂时限制到同时5个并行加载
                loadHub.Init(pathHub, new List<AsyncLoadRule>
                {
                    new AsyncLoadRule(int.MaxValue, 5)
                });
                var downloadHub = new BundleDownloadHub();
                // 后台下载限制到最大一个；主动加载限制到最大三个；
                downloadHub.Init(pathHub, new List<AsyncLoadRule>
                {
                    new AsyncLoadRule(0,            1),
                    new AsyncLoadRule(int.MaxValue, 3)
                });
                downloadHub.onComplete += pathHub.DownloadComplete;
                // 注：BundleManager需要在PathHub绑定后执行初始化，否则无法正确更新PathData
                var bundleManager = new BundleManager(pathHub, loadHub, downloadHub);
                if (AssetManager.instance == null)
                    AssetManager.CreateInstance();
                var assetManager = AssetManager.instance;
                // ReSharper disable once PossibleNullReferenceException
                assetManager.Init(bundleManager);
            }
        }

        DontDestroyOnLoad(gameObject);
    }

    public void StartBackGround()
    {
        if (!AssetUpdateManager.useResources)
            AssetManager.instance.bundleManager.downloadHub.StartBackGroundDownload();
    }

    public static void CreateInstance()
    {
        var loadObject = new GameObject("LoadAssetBundle");
        loadObject.AddComponent<LoadAssetBundle>();
    }

    public void ClearCallbacks()
    {
        _gameObjectList.Clear();
        _assetList.Clear();
        _audioList.Clear();
        _textAssetList.Clear();
        _spriteList.Clear();
        _rawImageList.Clear();
    }

    private bool IsBundleAndAssetValid(string bundleName, string assetName)
    {
        return !string.IsNullOrEmpty(bundleName) &&
               !string.IsNullOrEmpty(assetName)  &&
               !bundleName.Equals("-1")          &&
               !assetName.Equals("-1");
    }

    private void LoadAssetFromList<T>(string    bundleName, string assetName, LoadBundleAssetCallback<T> callback,
                                      Hashtable hashtable,  LoadAssetRequestList<T> list, bool archive) where T : Object
    {
        // 已知问题，即使已经加载的资源，仍然会产生一次列表推入和回调监听，造成少量性能浪费
        // 暂时不修改这个结构，保持当前强健的逻辑流程
        list.AddCallback(bundleName, assetName, callback, hashtable);
        LoadAssetInternal<T>(bundleName, assetName);
    }

    private void RemoveAllCallback(string bundleName, string assetName)
    {
        _gameObjectList.RemoveAllCallback(bundleName, assetName);
        _assetList.RemoveAllCallback(bundleName, assetName);
        _audioList.RemoveAllCallback(bundleName, assetName);
        _textAssetList.RemoveAllCallback(bundleName, assetName);
        _spriteList.RemoveAllCallback(bundleName, assetName);
        _rawImageList.RemoveAllCallback(bundleName, assetName);
    }

    public void LoadGameObject(string    bundleName, string assetName, LoadBundleAssetCallback<GameObject> callback,
                               Hashtable hashParam,  bool   archive = false)
    {
        if (IsBundleAndAssetValid(bundleName, assetName))
        {
            bundleName += assetName;
            bundleName =  FixBundleName(bundleName);
            LoadAssetFromList(bundleName, assetName, callback, hashParam, _gameObjectList, archive);
        }
    }

    public void LoadAsset(string    bundleName, string assetName, LoadBundleAssetCallback<Object> callback,
                          Hashtable hashParam,  bool   archive = false)
    {
        if (IsBundleAndAssetValid(bundleName, assetName))
        {
            bundleName = FixBundleName(bundleName);
            LoadAssetFromList(bundleName, assetName, callback, hashParam, _assetList, archive);
        }
    }

    public void RemoveAssetCallback(string bundleName, string assetName, LoadBundleAssetCallback<Object> callback)
    {
        if (IsBundleAndAssetValid(bundleName, assetName))
        {
            bundleName = FixBundleName(bundleName);
            _assetList.RemoveCallback(bundleName, assetName, callback);
        }
    }

    /// <summary>
    ///     GameObject加载需求的析构接口，因为会修改AssetBundle名称，使用一个统一接口
    /// </summary>
    public void UnloadAssetWithPathFix(string bundleName, string assetName)
    {
        if (!AssetUpdateManager.useResources && IsBundleAndAssetValid(bundleName, assetName))
        {
            bundleName = bundleName + assetName;
            bundleName = FixBundleName(bundleName);
            RemoveAllCallback(bundleName, assetName);
            AssetManager.instance.RemoveAsset(bundleName, assetName);
        }
    }

    /// <summary>
    ///     GameObject加载需求的析构接口，不会修改bundleName，因此不要给会用资源名校正包名资源的使用
    /// </summary>
    public void UnloadAsset(string bundleName, string assetName)
    {
        if (!AssetUpdateManager.useResources && IsBundleAndAssetValid(bundleName, assetName))
        {
            bundleName = FixBundleName(bundleName);
            RemoveAllCallback(bundleName, assetName);
            AssetManager.instance.RemoveAsset(bundleName, assetName);
        }
    }

    public void LoadUI(string    bundleName, string assetName, LoadBundleAssetCallback<GameObject> callback,
                       Hashtable hashParam,  bool   archive = true)
    {
        if (IsBundleAndAssetValid(bundleName, assetName))
        {
            bundleName = FixBundleName(bundleName);
            LoadAssetFromList(bundleName, assetName, callback, hashParam, _gameObjectList, archive);
        }
    }

    public void LoadSoundAsync(string    bundlePath, string assetName, LoadBundleAssetCallback<AudioClip> callback,
                               Hashtable hashParam)
    {
        if (!string.IsNullOrEmpty(assetName))
            if (IsBundleAndAssetValid(bundlePath, assetName))
            {
                bundlePath = FixBundleName(bundlePath);
                LoadAssetFromList(bundlePath, assetName, callback, hashParam, _audioList, true);
            }
    }

    public void SetRawTexture(RawImage image, string assetName, string bundleName)
    {
        var valid = false;
        if (image != null)
        {
            if (image.texture == null)
            {
                image.enabled = false;
                valid         = true;
            }
            else
            {
                valid = !image.texture.name.Equals(assetName);
            }
        }

        if (valid && IsBundleAndAssetValid(bundleName, assetName))
        {
            bundleName = FixBundleName(bundleName);
            _rawImageList.AddCallback(bundleName, assetName, image);
            LoadAssetInternal<Texture>(bundleName, assetName);
        }
    }

    public void SetImageSprite(Image image, string assetName, LoadSpritesCallback callback = null)
    {
        var valid = false;
        if (image != null)
        {
            if (image.sprite == null)
            {
                image.enabled = false;
                valid         = true;
            }
            else
            {
                valid = !image.sprite.name.Equals(assetName);
            }
        }

        if (valid && IsBundleAndAssetValid(BUNDLE_PATH_SPRITE, assetName))
        {
            // 试图校正精灵包名
            var bundleName = GetAtlasBundleName(BUNDLE_PATH_SPRITE, assetName);
            _spriteList.AddCallback(bundleName, assetName, image, callback);
            LoadAssetInternal<Sprite>(bundleName, assetName);
        }
    }

    /// <summary>
    ///     统一使用一个接口来处理修复Bundle名称之类的问题
    /// </summary>
    private void LoadAssetInternal<T>(string bundleName, string assetName) where T : Object
    {
#if UNITY_EDITOR
        if (AssetUpdateManager.useResources)
            LoadForSimulateMode(bundleName, assetName, typeof(T));
        else
#endif
            AssetManager.instance.LoadAsset<T>(bundleName, assetName, this, OnAssetLoadedFinish);
    }

    private void OnAssetLoadedFinish<T>(string bundleName, string assetName, T asset) where T : Object
    {
        _gameObjectList.FinishAsset(bundleName, assetName, asset);
        _assetList.FinishAsset(bundleName, assetName, asset);
        _audioList.FinishAsset(bundleName, assetName, asset);
        _textAssetList.FinishAsset(bundleName, assetName, asset);
        _spriteList.FinishAsset(bundleName, assetName, asset);
        _rawImageList.FinishAsset(bundleName, assetName, asset);
    }


#if UNITY_EDITOR
    [Serializable]
    public class EditorBundleList
    {
        private readonly Dictionary<string, string> _assetDataList = new Dictionary<string, string>();

        public EditorBundleList(IEnumerable<string> assets)
        {
            foreach (var asset in assets)
            {
                _assetDataList[Path.GetFileName(asset).ToLower()] = asset;
            }
        }

        public string GetAssetPath(string assetName)
        {
            string result;
            if (!_assetDataList.TryGetValue(assetName, out result))
                result = string.Empty;
            return result;
        }
    }

    private class EditorResourceAsync
    {
        public readonly string         bundleName;
        public readonly string         assetName;
        public readonly AsyncOperation operation;

        public EditorResourceAsync(string bundleName, string assetName, AsyncOperation operation)
        {
            this.bundleName = bundleName;
            this.assetName  = assetName;
            this.operation  = operation;
        }
    }

    public const string assetPathHeader = "Assets/Project3D/Resources";
    public const string uiSpriteAssetPath = "Assets/Project3D/Sprites";
    public const string bundleToAssetPath = "Assets/Editor/Config/BundleToAsset" + AssetConst.bytesExtension;
    private      Dictionary<string, string> _uiCommonPathDict;
    private      Dictionary<string, EditorBundleList> _resourcesDict;

    private const    int                            _maxAsyncCount = 1;
    private readonly List<EditorResourceAsync>      _asyncList     = new List<EditorResourceAsync>();
    private readonly Queue<MyTuple<string, string>> _pendingList   = new Queue<MyTuple<string, string>>();

    private void OnResourcesLoad(AsyncOperation operation)
    {
        var resourceRequest = operation as ResourceRequest;
        if (resourceRequest != null)
        {
            for (var i = _asyncList.Count - 1; i >= 0; i--)
            {
                var async = _asyncList[i];
                if (async.operation == operation)
                {
                    _asyncList.RemoveAt(i);
                    OnAssetLoadedFinish(async.bundleName, async.assetName, resourceRequest.asset);
                }
            }

            while (_asyncList.Count < _maxAsyncCount && _pendingList.Count > 0)
            {
                var task = _pendingList.Dequeue();
                StartResourceLoad(task.first, task.second);
            }
        }
    }

    private void StartResourceLoad(string bundleName, string assetName)
    {
        if (_resourcesDict == null)
        {
            var dataPath = Application.dataPath.MoveUp().Open(bundleToAssetPath);
            if (File.Exists(dataPath))
            {
                var bitFormatter = new BinaryFormatter();
                using (var fs = File.OpenRead(dataPath))
                    _resourcesDict = bitFormatter.Deserialize(fs) as Dictionary<string, EditorBundleList>;
            }

            if (_resourcesDict == null)
                _resourcesDict = new Dictionary<string, EditorBundleList>();
        }

        EditorBundleList list;
        if (!_resourcesDict.TryGetValue(bundleName, out list))
        {
            var assets = AssetDatabase.GetAssetPathsFromAssetBundle(bundleName + AssetConst.bundleVariant)
                                      .Where(a => a.StartsWith(assetPathHeader))
                                      .Select(a => a.RemoveExtension().Substring(assetPathHeader.Length + 1)).ToArray();
            if (assets.Length > 0)
            {
                list                       = new EditorBundleList(assets);
                _resourcesDict[bundleName] = list;
                var bitFormatter = new BinaryFormatter();
                var dataPath     = Application.dataPath.MoveUp().Open(bundleToAssetPath);
                using (var fs = File.OpenWrite(dataPath))
                    bitFormatter.Serialize(fs, _resourcesDict);
            }
        }

        var path = list != null
            ? list.GetAssetPath(assetName.ToLower())
            : string.Empty;
        if (string.IsNullOrEmpty(path))
        {
            Debug.LogError(string.Format("Unable to load asset {0} from bundle {1}!", assetName, bundleName));
            // ReSharper disable once ExpressionIsAlwaysNull
            OnAssetLoadedFinish(bundleName, assetName, default(Object));
        }
        else
        {
            var request = Resources.LoadAsync(path);
            _asyncList.Add(new EditorResourceAsync(bundleName, assetName, request));
            request.completed += OnResourcesLoad;
        }
    }

    private void LoadForSimulateMode(string bundleName, string assetName, Type assetType)
    {
        Object asset = null;
        // 2019.03.01 不再试图维护Simulate的流程；uiCommonSprite直接走内置流程。
        if (bundleName.StartsWith("ui/sprite/"))
        {
            if (_uiCommonPathDict == null)
            {
                _uiCommonPathDict = new Dictionary<string, string>();
                var uiCommonPaths = from assetPath in AssetDatabase.GetAllAssetPaths()
                    where assetPath.StartsWith(uiSpriteAssetPath)
                    where !string.IsNullOrEmpty(Path.GetExtension(assetPath))
                    select assetPath;
                foreach (var uiPath in uiCommonPaths)
                {
                    var key = Path.GetFileNameWithoutExtension(uiPath).ToLower();
                    if (_uiCommonPathDict.ContainsKey(key))
                        Debug.LogError("Duplicate Key Found for " + uiPath + " and " + _uiCommonPathDict[key]);
                    else
                        _uiCommonPathDict.Add(key, uiPath);
                }
            }

            string path;
            if (_uiCommonPathDict.TryGetValue(assetName.ToLower(), out path))
                asset = AssetDatabase.LoadAssetAtPath(path, assetType);
            else
                Debug.LogError("No Path for item " + assetName.ToLower());
            OnAssetLoadedFinish(bundleName, assetName, asset);
        }
        else
        {
            var callBack = _asyncList.Find(a => a.bundleName == bundleName && a.assetName == assetName);
            if (callBack == null)
            {
                if (_asyncList.Count < _maxAsyncCount)
                    StartResourceLoad(bundleName, assetName);
                else
                    _pendingList.Enqueue(new MyTuple<string, string>(bundleName, assetName));
            }
        }
    }
#endif

    #endregion

    #region load init

    public static LoadAssetBundle Instance { get; private set; }

    // public void UnloadBundle(string bundleName)
    // {
    //     Debug.Log("Unload Bundle: " + bundleName);
    //     if (!AssetUpdateManager.useResources)
    //     {
    //         bundleName = FixBundleName(bundleName);
    //         AssetManager.instance.RemovePreload(bundleName);
    //     }
    // }

    /// <summary>
    ///     统一处理一些AssetBundle后缀名称问题
    /// </summary>
    public static string FixBundleName(string bundleName)
    {
        // var extension = Path.GetExtension();
        // if (string.IsNullOrEmpty(extension))
        // {
        //     bundleName += bundleFileExtension;
        // }
        // else if (!extension.Equals(bundleFileExtension, StringComparison.CurrentCultureIgnoreCase))
        // {
        //     bundleName = bundleName.Remove(bundleName.Length - extension.Length);
        //     bundleName += bundleFileExtension;
        // }
        return bundleName.RemoveExtension().ToLower();
    }

    // /// <summary>
    // ///     加载一个AssetBundle，如果Bundle已经加载就返回true
    // /// </summary>
    // private void LoadOneAssetBundle(string bundleName)
    // {
    //     bundleName = FixBundleName(bundleName);
    //     AssetManager.instance.Preload(bundleName, this, OnAssetBundleLoaded);
    // }

    #endregion

    #region 预加载过场动画

    /// <summary>
    ///     预加载场景电影Bundle
    /// </summary>
    private readonly List<int> _movieId = new List<int>();

    private string _preloadScene;

    private static string GetMovieName(int movieId)
    {
        var movieName = string.Empty;
        if (movieId >= 0)
        {
            var movieData = TableManager.GetSceneMovieByID(movieId);
            if (movieData != null)
            {
                var profession = GameManager.gameManager.PlayerDataPool.MainPlayerBaseAttr.Profession;
                movieName = movieData.GetResPathbyIndex(profession);
            }
        }

        return movieName;
    }

    private void AddMoviePreload(int movieId)
    {
        var movieName = GetMovieName(movieId);
        if (!string.IsNullOrEmpty(movieName))
            Instance.LoadGameObject(BUNDLE_PATH_MODEL, movieName, null, null);
    }

    private void RemoveMoviePreload(int movieId)
    {
        var movieName = GetMovieName(movieId);
        if (!string.IsNullOrEmpty(movieName))
        {
            var bundleName = BUNDLE_PATH_MODEL + movieName;
            bundleName = FixBundleName(bundleName);
            Instance.UnloadAsset(bundleName, movieName);
        }
    }

    public void StartPreloadScene(string sceneName, int movieId)
    {
#if UNITY_EDITOR
        if (AssetUpdateManager.useResources)
            return;
#endif
        sceneName = GetSceneBundleName(sceneName);
        // 如果场景对不上，则卸载之前的场景预加载
        var loadScene = _preloadScene != sceneName;
        if (loadScene)
        {
            if (!string.IsNullOrEmpty(_preloadScene))
                CleanPreloadScene();
            _preloadScene = sceneName;
        }

        if (!_movieId.Contains(movieId))
            AddMoviePreload(movieId);
    }

    public void CleanPreloadScene()
    {
        _preloadScene = string.Empty;
        foreach (var id in _movieId)
            RemoveMoviePreload(id);
        _movieId.Clear();
    }

    #endregion

    #region loadScene

    /// <summary>
    ///     是否允许加载场景
    /// </summary>
    // 注：如果当前有其他SceneLoadOperaction，则不允许继续加载场景
    public bool AllowLoadScene()
    {
        return !AssetManager.instance.IsLoadingScene();
    }

    public static string GetSceneBundleName(string sceneName)
    {
        var bundleName = "scene/" + sceneName;
        bundleName = FixBundleName(bundleName);
        return bundleName;
    }

    public void UnloadMainScene()
    {
        if (!AssetUpdateManager.useResources)
            AssetManager.instance.UnloadAllScene();
    }

    /// <summary>
    ///     加载主要场景 - 主要场景加载时，会卸载之前的主要场景
    /// </summary>
    public bool LoadMainScene(string assetName, LoadSceneMode mode, out SceneHandle loadHandle)
    {
        bool load;
        if (AssetUpdateManager.useResources)
        {
            load       = true;
            loadHandle = null;
            SceneManager.LoadScene(assetName);
        }
        else
        {
            var bundleName = GetSceneBundleName(assetName);
            var current    = AssetManager.instance.GetCurrentSceneHandle();
            load = current == null || current.sceneName == assetName;
            if (!load)
                load = AllowLoadScene();
            loadHandle = load ? AssetManager.instance.LoadScene(bundleName, assetName, mode, allowReload: true) : null;
        }

        return load;
    }

    #endregion

    #region loadGameRes

    public static string gameResBundleName
    {
        get { return FixBundleName(BUNDLE_PATH_GAMERES); }
    }

    #endregion

    #region LoadTable

    private const string _tableBundleName = "tables";

    public TextAsset LoadTableAsset(string tableName)
    {
        return LoadTextAsset(_tableBundleName, tableName);
    }

#if UNITY_EDITOR
    public const string                     tablePath = "Assets/Project3D/BundleData/Tables3D/";
    private      Dictionary<string, string> _luaFiles;
#endif
    private TextAsset LoadTextAsset(string bundleName, string assetName)
    {
        TextAsset result = null;
#if UNITY_EDITOR
        if (AssetUpdateManager.useResources)
        {
            if (bundleName == _scriptBundleName)
            {
                if (_luaFiles == null)
                {
                    _luaFiles = new Dictionary<string, string>();
                    var luaPath = "Assets".Open("Project").Open("Script").Open("LuaScripts") + '/';
                    var scripts = AssetDatabase.GetAllAssetPaths().Where(a => a.StartsWith(luaPath))
                                               .Where(a => AssetConst.textExtension.Equals(Path.GetExtension(a)));
                    foreach (var script in scripts)
                        _luaFiles.Add(Path.GetFileNameWithoutExtension(script).ToLower(), script);
                }

                string path;
                if (_luaFiles.TryGetValue(assetName.ToLower(), out path))
                    result = AssetDatabase.LoadAssetAtPath<TextAsset>(path);
            }
            else if (bundleName == _tableBundleName)
            {
                var extension = string.Equals(assetName, atlasPathConvertTable, StringComparison.Ordinal)
                    ? AssetConst.bytesExtension
                    : AssetConst.textExtension;
                result = AssetDatabase.LoadAssetAtPath<TextAsset>(tablePath + assetName + extension);
            }
            else
                Debug.LogError(string.Format("Unable to load TextAsset {1} from bundle {0}!", bundleName, assetName));

            return result;
        }
#endif
        if (AssetManager.instance == null)
        {
            throw new Exception("AssetManager is not initialized!");
        }

        result = AssetManager.instance.LoadAssetSync<TextAsset>(bundleName, assetName);
        return result;
    }

    #endregion

    #region LoadScript

    // 注：之前逻辑是和LoadTable在一起，但是没有监听过这个AssetBundle是否加载结束的
    // 暂时保持接口和调用处不变
    private const string _scriptBundleName = "script";

    public TextAsset LoadScriptAsset(string script)
    {
        return LoadTextAsset(_scriptBundleName, script);
    }

    #endregion

    #region Atlas Path Convert

    private Dictionary<string, string> _pathConvertDict;

    private void CreateAtlasConvert()
    {
        _pathConvertDict = new Dictionary<string, string>();
        var lines = AssetUtils.TextToLines(LoadTableAsset(atlasPathConvertTable).text);
        foreach (var line in lines)
        {
            if (!string.IsNullOrEmpty(line))
            {
                var keyValue = line.Split('\t');
                _pathConvertDict[keyValue[0]] = keyValue[1];
            }
        }
    }

    private string GetAtlasBundleName(string bundleName, string assetName)
    {
        if (_pathConvertDict == null)
            CreateAtlasConvert();
        string newName;
        if (_pathConvertDict.TryGetValue(assetName.ToLower(), out newName))
            bundleName = newName;
        else
        {
            LogModule.ErrorLog(string.Format(
                                             "Try to load asset {0} from {1}, while Asset Load Manager hasn't init path conversion yet!",
                                             assetName, bundleName));
        }

        return bundleName;
    }

    #endregion
}

#region Load Asset Data

public delegate void LoadSpritesCallback(bool isSucess, GameObject obj);

public delegate void LoadBundleAssetCallback<in T>(string assetName, T assetItem, Hashtable hashTable) where T : Object;

public delegate void LoadAssetBundleFinish(string bundleName);

public abstract class LoadAssetRequestBase
{
    public readonly string assetName;
    public readonly string bundleName;

    protected LoadAssetRequestBase(string bundleName, string assetName)
    {
        this.bundleName = bundleName;
        this.assetName  = assetName;
    }
}

public static class LoadAssetRequestMethods
{
    public static int GetIndexFromList<T>(this List<T> requestList, string bundleName, string assetName)
        where T : LoadAssetRequestBase
    {
        var result = -1;
        for (var i = 0; i < requestList.Count; i++)
            if (requestList[i].bundleName.Equals(bundleName, StringComparison.OrdinalIgnoreCase) &&
                requestList[i].assetName.Equals(assetName, StringComparison.Ordinal))
            {
                result = i;
                break;
            }

        return result;
    }
}

public class LoadRawImageRequest : LoadAssetRequestBase
{
    public readonly List<RawImage> rawImageList = new List<RawImage>();

    public LoadRawImageRequest(string bundleName, string assetName) : base(bundleName, assetName)
    {
    }

    public void AddCallback(RawImage rawImage)
    {
        if (!rawImageList.Contains(rawImage))
            rawImageList.Add(rawImage);
    }

    public void RemoveCallback(RawImage rawImage)
    {
        rawImageList.Remove(rawImage);
    }

    public void FinishAsset(Object asset)
    {
        var texture = asset as Texture;
        for (var i = 0; i < rawImageList.Count; i++)
            if (rawImageList[i])
            {
                rawImageList[i].texture = texture;
                rawImageList[i].enabled = true;
            }
    }
}

public class LoadSpriteRequest : LoadAssetRequestBase
{
    public readonly List<MyTuple<Image, LoadSpritesCallback>> callBackList =
        new List<MyTuple<Image, LoadSpritesCallback>>();

    public LoadSpriteRequest(string bundleName, string assetName) : base(bundleName, assetName)
    {
    }

    public void AddCallback(Image image, LoadSpritesCallback callback)
    {
        var index = GetCallBackIndex(image);
        if (index >= 0)
            callBackList[index].second = callback;
        else
            callBackList.Add(new MyTuple<Image, LoadSpritesCallback>(image, callback));
    }

    public void RemoveCallback(Image image)
    {
        var index = GetCallBackIndex(image);
        if (index >= 0)
            callBackList.RemoveAt(index);
    }

    private int GetCallBackIndex(Image image)
    {
        var result = -1;
        for (var i = 0; i < callBackList.Count; i++)
            if (callBackList[i].first == image)
            {
                result = i;
                break;
            }

        return result;
    }

    public void FinishAsset(Object asset)
    {
        var sprite = asset as Sprite;
        for (var i = 0; i < callBackList.Count; i++)
            if (callBackList[i].first)
            {
                callBackList[i].first.sprite  = sprite;
                callBackList[i].first.enabled = true;
                if (callBackList[i].second != null)
                    callBackList[i].second.Invoke(true, callBackList[i].first.gameObject);
            }
    }
}

public class LoadAssetRequest<T> : LoadAssetRequestBase where T : Object
{
    public readonly List<MyTuple<LoadBundleAssetCallback<T>, Hashtable>> callBackList =
        new List<MyTuple<LoadBundleAssetCallback<T>, Hashtable>>();

    public LoadAssetRequest(string bundleName, string assetName) : base(bundleName, assetName)
    {
    }

    public void AddCallback(LoadBundleAssetCallback<T> callback, Hashtable hashTable)
    {
        var index = GetCallbackIndex(callback);
        if (index < 0)
            callBackList.Add(new MyTuple<LoadBundleAssetCallback<T>, Hashtable>(callback, hashTable));
        else
            callBackList[index].second = hashTable;
    }

    public void RemoveCallback(LoadBundleAssetCallback<T> callback)
    {
        var index = GetCallbackIndex(callback);
        if (index >= 0)
            callBackList.RemoveAt(index);
    }

    private int GetCallbackIndex(LoadBundleAssetCallback<T> callback)
    {
        var result = -1;
        for (var i = 0; i < callBackList.Count; i++)
            if (callBackList[i].first == callback)
            {
                result = i;
                break;
            }

        return result;
    }

    public void FinishAsset(Object asset)
    {
        var item = asset as T;
        for (var i = 0; i < callBackList.Count; i++)
            if (callBackList[i].first != null)
                callBackList[i].first.Invoke(assetName, item, callBackList[i].second);
    }
}

public class LoadRawImageRequestList
{
    private readonly List<LoadRawImageRequest> _callbackList = new List<LoadRawImageRequest>();

    public void AddCallback(string bundleName, string assetName, RawImage rawImage)
    {
        var                 index = _callbackList.GetIndexFromList(bundleName, assetName);
        LoadRawImageRequest request;
        if (index < 0)
        {
            request = new LoadRawImageRequest(bundleName, assetName);
            _callbackList.Add(request);
        }
        else
        {
            request = _callbackList[index];
        }

        request.AddCallback(rawImage);
    }

    public void RemoveCallback(string bundleName, string assetName, RawImage rawImage)
    {
        var index = _callbackList.GetIndexFromList(bundleName, assetName);
        if (index >= 0)
        {
            _callbackList[index].RemoveCallback(rawImage);
            if (_callbackList[index].rawImageList.Count <= 0)
                _callbackList.RemoveAt(index);
        }
    }

    public void RemoveAllCallback(string bundleName, string assetName)
    {
        var index = _callbackList.GetIndexFromList(bundleName, assetName);
        if (index >= 0)
            _callbackList.RemoveAt(index);
    }

    public void FinishAsset(string bundleName, string assetName, Object asset)
    {
        // 这个接收底层回调的消息，不会出现名字错误的问题
        var index = _callbackList.GetIndexFromList(bundleName, assetName);
        if (index >= 0)
        {
            var item = _callbackList[index];
            _callbackList.RemoveAt(index);
            item.FinishAsset(asset);
        }
    }

    public void Clear()
    {
        _callbackList.Clear();
    }
}

public class LoadSpriteRequestList
{
    private readonly List<LoadSpriteRequest> _callbackList = new List<LoadSpriteRequest>();

    public void AddCallback(string bundleName, string assetName, Image image, LoadSpritesCallback callback)
    {
        bundleName = LoadAssetBundle.FixBundleName(bundleName);
        var               index = _callbackList.GetIndexFromList(bundleName, assetName);
        LoadSpriteRequest request;
        if (index < 0)
        {
            request = new LoadSpriteRequest(bundleName, assetName);
            _callbackList.Add(request);
        }
        else
        {
            request = _callbackList[index];
        }

        request.AddCallback(image, callback);
    }

    public void RemoveCallback(string bundleName, string assetName, Image image)
    {
        bundleName = LoadAssetBundle.FixBundleName(bundleName);
        var index = _callbackList.GetIndexFromList(bundleName, assetName);
        if (index >= 0)
        {
            _callbackList[index].RemoveCallback(image);
            if (_callbackList[index].callBackList.Count <= 0)
                _callbackList.RemoveAt(index);
        }
    }

    public void RemoveAllCallback(string bundleName, string assetName)
    {
        bundleName = LoadAssetBundle.FixBundleName(bundleName);
        var index = _callbackList.GetIndexFromList(bundleName, assetName);
        if (index >= 0)
            _callbackList.RemoveAt(index);
    }

    public void FinishAsset(string bundleName, string assetName, Object asset)
    {
        // 这个接收底层回调的消息，不会出现名字错误的问题
        var index = _callbackList.GetIndexFromList(bundleName, assetName);
        if (index >= 0)
        {
            var item = _callbackList[index];
            _callbackList.RemoveAt(index);
            item.FinishAsset(asset);
        }
    }

    public void Clear()
    {
        _callbackList.Clear();
    }
}

public class LoadAssetRequestList<T> where T : Object
{
    private readonly List<LoadAssetRequest<T>> _callbackList = new List<LoadAssetRequest<T>>();

    public void AddCallback(string    bundleName, string assetName, LoadBundleAssetCallback<T> callback,
                            Hashtable hashTable)
    {
        var                 index = _callbackList.GetIndexFromList(bundleName, assetName);
        LoadAssetRequest<T> request;
        if (index < 0)
        {
            request = new LoadAssetRequest<T>(bundleName, assetName);
            _callbackList.Add(request);
        }
        else
        {
            request = _callbackList[index];
        }

        request.AddCallback(callback, hashTable);
    }

    public void RemoveCallback(string bundleName, string assetName, LoadBundleAssetCallback<T> callback)
    {
        var index = _callbackList.GetIndexFromList(bundleName, assetName);
        if (index >= 0)
        {
            _callbackList[index].RemoveCallback(callback);
            if (_callbackList[index].callBackList.Count <= 0)
                _callbackList.RemoveAt(index);
        }
    }

    public void RemoveAllCallback(string bundleName, string assetName)
    {
        var index = _callbackList.GetIndexFromList(bundleName, assetName);
        if (index >= 0)
            _callbackList.RemoveAt(index);
    }

    public void FinishAsset(string bundleName, string assetName, Object asset)
    {
        // 这个接收底层回调的消息，不会出现名字错误的问题
        var index = _callbackList.GetIndexFromList(bundleName, assetName);
        if (index >= 0)
        {
            var item = _callbackList[index];
            _callbackList.RemoveAt(index);
            item.FinishAsset(asset);
        }
    }

    public void Clear()
    {
        _callbackList.Clear();
    }
}

/// <summary>
///     部分系统会需要穿越Asset级别，直接操作AssetBundle，保留这么一个回调
/// </summary>
public class LoadWholeBundleRequest
{
    public readonly List<LoadAssetBundleFinish> callbackList = new List<LoadAssetBundleFinish>();
    public readonly string                      name;

    public LoadWholeBundleRequest(string bundleName)
    {
        name = bundleName;
    }

    public void AddCallback(LoadAssetBundleFinish callback)
    {
        if (!callbackList.Contains(callback))
            callbackList.Add(callback);
    }

    public void RemoveCallback(LoadAssetBundleFinish callback)
    {
        callbackList.Remove(callback);
    }

    public void FinishAssetBundleLoad()
    {
        for (var i = 0; i < callbackList.Count; i++)
            try
            {
                if (callbackList[i] != null)
                    callbackList[i].Invoke(name);
            }
            catch (Exception e)
            {
                LogModule.ErrorLog(e.ToString());
            }
    }
}

// public class LoadWholeBundleList
// {
//     private readonly List<LoadWholeBundleRequest> _callbackList = new List<LoadWholeBundleRequest>();
//
//     public void AddCallback(string bundleName, LoadAssetBundleFinish callback)
//     {
//         var index = GetCallbackIndex(bundleName);
//         LoadWholeBundleRequest request;
//         if (index < 0)
//         {
//             request = new LoadWholeBundleRequest(bundleName);
//             _callbackList.Add(request);
//         }
//         else
//         {
//             request = _callbackList[index];
//         }
//
//         request.AddCallback(callback);
//     }
//
//     public void RemoveCallback(string bundleName, LoadAssetBundleFinish callback)
//     {
//         var index = GetCallbackIndex(bundleName);
//         if (index >= 0)
//         {
//             _callbackList[index].RemoveCallback(callback);
//             if (_callbackList[index].callbackList.Count <= 0)
//                 _callbackList.RemoveAt(index);
//         }
//     }
//
//     public void FinishBundle(string bundleName)
//     {
//         var index = GetCallbackIndex(bundleName);
//         if (index >= 0)
//         {
//             var item = _callbackList[index];
//             _callbackList.RemoveAt(index);
//             item.FinishAssetBundleLoad();
//         }
//     }
//
//     private int GetCallbackIndex(string bundleName)
//     {
//         var index = -1;
//         for (var i = 0; i < _callbackList.Count; i++)
//             if (_callbackList[i].name.Equals(bundleName, StringComparison.OrdinalIgnoreCase))
//             {
//                 index = i;
//                 break;
//             }
//
//         return index;
//     }
//
//     public void Clear()
//     {
//         _callbackList.Clear();
//     }
// }

#endregion