Unity5.X AssetBundle加载（增加路径处理）

1.增加对persistentDataPath文件夹的检测

2.如果persistentDataPath文件夹下没有目标ab 再对StreamingAssets文件夹进行检测

3.ab更新到persistentDataPath文件夹中（下一篇会写这个）

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Text;
using System.IO;


public class AssetLoader
{
    private string streamingAssetDataPath;
    private string persistentDataPath;


    private StringBuilder url;


    public AssetLoader()
    {
        streamingAssetDataPath =
#if UNITY_ANDROID
     "jar:file://" + Application.dataPath + "!/assets/AssetBundle/Android/";
#elif UNITY_IPHONE
     //Application.dataPath + "/Raw/AssetBundle/IOS/";
     "file://" +Application.dataPath + "/Raw/AssetBundle/IOS/";


#elif UNITY_STANDALONE_WIN || UNITY_EDITOR
     "file://" + Application.dataPath + "/StreamingAssets/";
#else
        string.Empty; 
#endif
        persistentDataPath = Application.persistentDataPath + "/";


        url = new StringBuilder();
    }


    public string GetDownLoadURL(string name)
    {
        url.Remove(0, url.Length);


        if (File.Exists(persistentDataPath + name))
        {
            url.Append("file:///" + persistentDataPath + name);
        }
        else
        {
            url.Append(streamingAssetDataPath + name);
        }


        Debug.Log("DownLoadURL____" + name + "____" + url.ToString());


        return url.ToString();
    }






    public string GetStreamPath(string name)
    {
        url.Remove(0, url.Length);


        if (File.Exists(persistentDataPath + name))
        {
            url.Append(persistentDataPath + name);
        }
        else
        {
            url.Append(Application.streamingAssetsPath + "/" + name);
        }


        Debug.Log("DownLoadURL____" + name + "____" + url.ToString());


        return url.ToString();
    }




}

//ab加载管理器  和前一篇一样，只是修改了url的获取方法

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;


public class AssetLoaderManager : MonoBehaviour {


    #region 声明变量


    #region 单例


    private static AssetLoaderManager instance;
    public static AssetLoaderManager Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new GameObject("AssetLoaderManager").AddComponent<AssetLoaderManager>();
            }
            return instance;
        }
    }


    #endregion


    #region 加载


    /// <summary>
    /// 获取下载路径
    /// </summary>
    private AssetLoader loader;


    /// <summary>
    /// AssetBundleManifest 总体的AssetBundleManifest
    /// </summary>
    private AssetBundleManifest mainAssetBundleManifest;


    /// <summary>
    /// 总体的AssetBundleManifest 名字
    /// </summary>
    public string assetBundleManifestName = "";


    /// <summary>
    /// 下载完后的委托
    /// </summary>
    /// <param name="www"></param>
    public delegate void HandleFinishDownload(WWW www);


    /// <summary>
    /// 加载完后的委托
    /// </summary>
    /// <param name="go"></param>
    public delegate void HandleFinishInstantiate(Object go);


    #endregion


    #region 卸载


    /// <summary>
    /// 已经加载过的AssetBundle
    /// </summary>
    Dictionary<string, LoadedAssetBundle> loadedAssetBundles;
    /// <summary>
    /// 依赖信息
    /// </summary>
    Dictionary<string, string[]> dependencies;


    #endregion




    #endregion


    #region 提供外部方法
    /// <summary>
    /// 加载所需要的AssetBundle
    /// </summary>
    /// <param name="assetBundleName"></param>
    /// <param name="instantiateFun"></param>
    /// <returns></returns>
    public IEnumerator LoadAssetBundle(string assetBundleName, HandleFinishInstantiate instantiateFun, bool isLoadScene = false)
    {
        AssetBundle assetBundle = null;


        assetBundle = LoadAssetBundleInternal(assetBundleName);


        if (assetBundle == null)
        {
            Debug.LogError("新加载____" + assetBundleName);
            //获取依赖文件列表
            string[] dependentAssetBundles = mainAssetBundleManifest.GetAllDependencies(assetBundleName);


            AddDependencies(assetBundleName, dependentAssetBundles);


            AssetBundle[] abs = new AssetBundle[dependentAssetBundles.Length];


            for (int i = 0; i < dependentAssetBundles.Length; i++)
            {
                //加载所有的依赖文件
                WWW www = new WWW(loader.GetDownLoadURL(dependentAssetBundles[i]));//URL + dependentAssetBundles[i]);
                yield return www;
                abs[i] = www.assetBundle;


                AddLoadedAssetBundles(dependentAssetBundles[i], new LoadedAssetBundle(abs[i]));
            }


            //加载需要的文件
            WWW loadAssetBundle = new WWW(loader.GetDownLoadURL(assetBundleName));//URL + assetBundleName);
            yield return loadAssetBundle;
            assetBundle = loadAssetBundle.assetBundle;


            AddLoadedAssetBundles(assetBundleName, new LoadedAssetBundle(assetBundle));


        }
        else
        {
            Debug.LogError("已经加载过了____" + assetBundleName);
        }


        if (isLoadScene)
        {
            //加载场景（使用场景名称）
            SceneManager.LoadScene(assetBundleName);
        }
        else
        {
            if (instantiateFun != null)
                instantiateFun(assetBundle.LoadAsset(assetBundleName));
        }


        //UnloadAssetBundle(assetBundleName);
    }


    /// <summary>
    /// 卸载目标AssetBundle
    /// </summary>
    /// <param name="assetBundleName"></param>
    /// <param name="unLoad"></param>
    public void UnloadAssetBundle(string assetBundleName, bool unLoad = false)
    {
        Debug.LogError("卸载____" + assetBundleName);
        UnloadAssetBundleInternal(assetBundleName, unLoad);
        UnloadDependencies(assetBundleName, unLoad);
    }


    #endregion


    #region 内部实现


    /// <summary>
    /// 初始化
    /// </summary>
    void Awake()
    {
        instance = this;
        Initialize();
    }


    /// <summary>
    /// 实例化
    /// </summary>
    void Initialize()
    {
        loader = new AssetLoader();
        assetBundleManifestName = "StreamingAssets";
        LoadMainAssetBundleManifest();


        loadedAssetBundles = new Dictionary<string, LoadedAssetBundle>();
        dependencies = new Dictionary<string, string[]>();
    }


    /// <summary>
    /// 加载总体的AssetBundleManifest
    /// </summary>
    void LoadMainAssetBundleManifest()
    {
        StartCoroutine(DownLoad(loader.GetDownLoadURL(assetBundleManifestName), delegate (WWW www)
        {
            AssetBundle manifestBundle = www.assetBundle;
            mainAssetBundleManifest = (AssetBundleManifest)manifestBundle.LoadAsset("AssetBundleManifest");
            manifestBundle.Unload(false);
        }
));
    }


    /// <summary>
    /// 下载WWW
    /// </summary>
    /// <param name="url"></param>
    /// <param name="finishFun"></param>
    /// <returns></returns>
    private IEnumerator DownLoad(string url, HandleFinishDownload finishFun)
    {
        WWW www = new WWW(url);
        yield return www;
        if (www.error != null) Debug.LogError(www.error + "_______________________________/" + url);
        if (finishFun != null)
            finishFun(www);
        www.Dispose();
    }


    /// <summary>
    /// dependencies 增
    /// </summary>
    /// <param name="mKey"></param>
    /// <param name="mValue"></param>
    private void AddDependencies(string mKey, string[] mValue)
    {
        dependencies.Add(mKey, mValue);
    }


    /// <summary>
    /// dependencies 删
    /// </summary>
    /// <param name="mKey"></param>
    private void UnloadDependencies(string mKey, bool unLoad = false)
    {
        string[] mDependencies = null;
        if (!dependencies.TryGetValue(mKey, out mDependencies)) return;


        foreach (var dependency in mDependencies)
        {
            UnloadAssetBundleInternal(dependency, unLoad);
        }


        dependencies.Remove(mKey);
    }


    /// <summary>
    /// loadedAssetBundles 增
    /// </summary>
    /// <param name="mKey"></param>
    /// <param name="mValue"></param>
    private void AddLoadedAssetBundles(string mKey, LoadedAssetBundle mValue)
    {
        loadedAssetBundles.Add(mKey, mValue);
    }


    /// <summary>
    /// 从内部加载AssetBundle
    /// </summary>
    /// <param name="assetBundleName"></param>
    /// <returns></returns>
    private AssetBundle LoadAssetBundleInternal(string assetBundleName)
    {
        LoadedAssetBundle bundle = null;
        loadedAssetBundles.TryGetValue(assetBundleName, out bundle);
        if (bundle != null)
        {
            bundle.referencedCount++;
            return bundle.assetBundle;
        }
        return null;
    }


    /// <summary>
    /// 从内部卸载AssetBundle
    /// </summary>
    /// <param name="assetBundleName"></param>
    private void UnloadAssetBundleInternal(string assetBundleName, bool unLoad = false)
    {
        LoadedAssetBundle bundle = GetLoadedAssetBundle(assetBundleName);
        if (bundle == null)
            return;


        if (--bundle.referencedCount == 0)
        {
            bundle.assetBundle.Unload(unLoad);
            loadedAssetBundles.Remove(assetBundleName);
        }
    }


    /// <summary>
    /// 获取加载过的AssetBundle
    /// </summary>
    /// <param name="assetBundleName"></param>
    /// <returns></returns>
    private LoadedAssetBundle GetLoadedAssetBundle(string assetBundleName)
    {
        LoadedAssetBundle bundle = null;
        loadedAssetBundles.TryGetValue(assetBundleName, out bundle);
        if (bundle == null)
            return null;


        string[] mDependencies = null;
        if (!dependencies.TryGetValue(assetBundleName, out mDependencies))
            return bundle;


        foreach (var dependency in mDependencies)
        {
            LoadedAssetBundle dependentBundle;
            loadedAssetBundles.TryGetValue(dependency, out dependentBundle);
            if (dependentBundle == null)
                return null;
        }


        return bundle;
    }


    #endregion


    #region 测试
    public string assetBundleName;
    public string changeMatName;


    void OnGUI()
    {
        if (GUILayout.Button("Load Cube"))
        {
            StartCoroutine(LoadAssetBundle(assetBundleName, delegate (Object go)
            {
                GameObject obj = Instantiate(go) as GameObject;
                obj.transform.position = new Vector3(Random.Range(0, 5), 0, Random.Range(0, 5));
            }, true));
        }


        if (GUILayout.Button("UnLoad Cube"))
        {
            UnloadAssetBundle(assetBundleName);
        }


        if (GUILayout.Button("UnLoad Cube True"))
        {
            UnloadAssetBundle(assetBundleName, true);
        }


        if (GUILayout.Button("ChangeMat"))
        {
            StartCoroutine(LoadAssetBundle(changeMatName, delegate (Object go)
            {
                GameObject obj = GameObject.Find("TestCube(Clone)");
                obj.GetComponent<MeshRenderer>().material = go as Material;
            }));
        }
    }


    #endregion


}