【原创】我所理解的资源加载方式

最近转战unity3d，接的第一个任务就是关于资源管理的部分。

由于项目是web和standalone（微端）并存的，所以希望保证业务逻辑尽量保持一致，跟之前ios，android的执行流程略有不同，比如在web模式下，FILE类是被禁用的，所以指望通过写文件来操作相关功能参数的方法是不可行的。下面，是我对这方面的一些理解。本文中如果没有特殊说明，下载的资源都是AssetBundle

web程序的运行流程大致是

首先加载web.html,这是整个程序的入口

他会加载相关的unity3d文件（本例中的web.unity3d）和unity3d平台所需要的文件（各种js文件）

基本资源加载完成后，进入界面。

其他使用时才下载的资源全部以AssetBundle的形式存放在远程目录，通过LoadFromCacheOrDownload函数传入版本号进行下载。

注意：unity为web版本的程序启用了50M的cache空间，所有下载的文件都存放在C:Users你的用户名AppDataLocalLowUnityWebPlayerCacheShared目录下

经过验证，web程序对于文件下载执行如下步骤

请求文件：http://xxxx/test/a.ab
1.代码中AB池里是否存在
2.unity cache里是否存在
3.浏览器缓存中是否存在
如果都不存在，则启动下载
下载完成后，根据浏览器的policy存入浏览器缓存，然后根据unity的policy存入unity的cache，最后代码中写入AB池以备后续使用。

standalone程序的运行流程跟web不太一样
1.exe文件包含打包进去的unity3d文件（scene文件）
2.目录，文件操作是启用的，比如Directory，File等

注意：

使用LoadFromCacheOrDownload方式下载的文件都是存放在C:Users你的用户名AppDataLocalLowUnityWebPlayerCache目录下，web版会放在Shard和Temp目录下，而standalone版则会放在单独的子目录（一个默认工程的名字大致是DefaultCompany_xxx）

通过以上流程，可以看出，standalone和web版本的加载方式不同，但是我们可以通过合理的处理达到实现不同但是使用一致的结果。

 先放一张整图，让大家有个整体的概念

整个流程描述大致是

启动游戏的时候，通过HTTP or WWW的方式下载version文件，里面保存【文件名， 修改时间， 依赖表】

当需要加载某个资源的时候，首先通过文件名获取文件的依赖关系表，然后生成下载文件列表

比如你想下载a.ab,但是a.ab文件依赖于c1.ab, c4.ab，那么最终生成的下载表就是[c1.ab, c4.ab, a.ab]，制作之初我有个误区，以为有依赖关系的文件必须先下载依赖关系文件再下载目标文件，还特意写了个有向图的算法来计算关联关系及执行顺序，实际上经过测试，不需要。只要保证下载列表完全下载完成再使用ab就ok了。

然后判断一下在ABPool里（我们自己实现的AssetBundle池）是否已经存在这个ab，如果存在就直接返回ab的句柄

如果没有，则执行分平台下载流程

关于下载，上面已经解释过，standalone和web版的加载方式是不一样的，所以这里对不同平台做了专门的处理

standalone：

    首先判断本地是否有这个文件，如果有，则判断本地这个文件的版本号是否是线上最新的版本号，如果不是，则通过HTTP方式下载文件，并保存到本地，然后通过WWW的方式将文件load到内存中，写入ABPool以备后续使用

web：

    传入下载地址和版本号，unity自己会判断是否需要下载文件。

    经过研究，LoadFromCacheOrDownload后面的version参数其实相当于一个key，并没有顺序的概念，当你通过5下载某个文件成功之后，底层会将这个文件的版本号改写成5，下次再调用的时候，就不会启动下载而是从cache里直接获取。如果你使用4作为版本号调用LoadFromCacheOrDownload的时候，底层会发现本地cache里并没有这个版本号的这个文件，然后重新下载。所有，只要版本号是变动的（唯一的，比如用文件修改时间作为版本号）
最终返回List表示已经加载结束

好了，大致流程就是这样，下面开始详细讲解每个功能

1.版本文件生成

我们这里的版本文件存放几个数据【文件名，verison，依赖表】

完整代码是

public class VersionList
{
    protected class Data { //元数据，存放文件名，修改时间和依赖表
        public Data(string _key, int _modifyTime, List<string> _depends) {
            key = _key;
            depends = _depends;
            modifyTime = _modifyTime;
        }

        public string key { get; set; }
        public int modifyTime { get; set; }
        public List<string> depends { get; set; }
    }

    static string s_bundleDir = "Res";  //导出目录
    static string s_versionFile = s_bundleDir + "/version.txt";  //资源文件
    static Dictionary<string, Data> s_files = new Dictionary<string, Data>(); //文件信息字典
    
//计算时间戳并转换成小时数（注意：这里使用的是小时数作为版本号，开发期间可能一个小时会打包多次，但是对于线上这是不被允许的<如果出现这种情况，说明开发和测试的工作没做好>）
    public static int dtToHours (DateTime dateTime)
    {
        var start = new DateTime(2016, 1, 1, 0, 0, 0, dateTime.Kind);
        return Convert.ToInt32((dateTime - start). TotalHours);
    }

//遍历目录，获取相关信息
    static void GetObjectInfoToArray(string  path)
    {
        string[] fs = Directory.GetFiles (path);
        foreach (string f in fs) {
            if(f.Contains(".meta")) //忽略meta文件
                continue;
            FileInfo fi = new FileInfo(f);
            if (!fi.Exists)
            {
                continue;
            }

            string _f = f.Replace( "\", "/" ); //统一目录分隔符

            List<string> _depends = new List<string>();
            string []paths = AssetDatabase.GetDependencies(new string[]{_f}); //获取当前文件的所依赖的文件列表
            foreach(string p in paths){
                string _p = p.Replace("\", "/");
                if (_p != _f) {
                    _depends.Add(_p);
                }
            }

             //将文件名，更新时间，依赖列表写入字典
            s_files.Add(_f, new Data(_f,  dtToHours (fi.LastWriteTime),  _depends)); 
        }

        try {
//遍历子目录
            string[] ds = Directory.GetDirectories(path);
            foreach(string d in ds) {
                GetObjectInfoToArray (d);
            }
        } catch (System.IO.DirectoryNotFoundException) {  
            Debug.Log ("The path encapsulated in the " + path + "Directory object does not exist.");  
        } 
    }
    
    [MenuItem( "VersionList/Generator" )]
    static void Generator()
    {
        Debug.Log ("Begin Generator VersionList");
        s_files.Clear ();

//创建res目录
        if (!Directory.Exists(s_bundleDir))
        {
            Directory.CreateDirectory(s_bundleDir);
        }

//删除老的version文件
        if (File.Exists (s_versionFile)) {
            File.Delete(s_versionFile);
        }

//遍历生成Assets下所有文件的版本信息
        GetObjectInfoToArray ("Assets");
        if (s_files.Keys.Count == 0) {
            return;
        }

//自定义格式写入文件
        FileInfo vf = new FileInfo (s_versionFile);
        StreamWriter sw = vf.CreateText ();

        foreach (KeyValuePair<string, Data> kv in s_files) {
            string tmp = kv.Key+";"+kv.Value.modifyTime;
            if (kv.Value.depends != null && kv.Value.depends.Count > 0) {
                tmp += ",";
                for (int i=0; i<kv.Value.depends.Count-1; ++i) {
                    tmp += kv.Value.depends[i];
                    tmp += ":"; 
                }
                
                tmp += kv.Value.depends[kv.Value.depends.Count - 1];                
            }
            sw.WriteLine(tmp);
        }

        sw.Close();
        sw.Dispose();

        Debug.Log ("End Generator VersionList");
    }
}

加载version文件

IEnumerator LoadVersionFile()
{
    Debug.Log("Begin Read VersionList");

    s_files.Clear();
    WWW www = new WWW("http://ldr123.mobi/webAU/test/version.ab");
    yield return www;

    string result = www.assetBundle.mainAsset.ToString();
    string[] r = result.Split(new string[] { "
" }, StringSplitOptions.RemoveEmptyEntries);
    foreach (string line in r)
    {
        string[] res = line.Split(';');
        if (res.Length == 2)
        {
            string key = res[0];
            string value = res[1];
            string[] values = value.Split(',');
            int modifyTime = int.Parse(values[0]);
            List<string> depends = null;
            if (values.Length == 2)
            {
                string d = values[1];
                string[] ds = d.Split(':');
                if (ds.Length > 0)
                {
                    depends = new List<string>();
                    foreach (string x in ds)
                    {
                        depends.Add(x);
                    }
                }
            }

            s_files.Add(key, new Data(key, modifyTime, depends));
        }
    }

    Debug.Log("End Read VersionList");
}

AB池的代码，以文件名为key存放所有已经加载的AssetBundle句柄

public class AssetBundlePool {
    private class Data
    {
        public Data(AssetBundle _ab, int _version)
        {
            ab = _ab;
            version = _version;
        }

        public AssetBundle ab { get; set; }
        public int version { get; set; }
    }

    private Dictionary<string, Data> abContent = null;

    public static AssetBundlePool instance = null;
    public static AssetBundlePool Instance()
    {
        if (instance == null)
        {
            instance = new AssetBundlePool();
        }

        return instance;
    }

    public AssetBundlePool()
    {
        abContent = new Dictionary<string, Data>();
    }

    public AssetBundle getAssetBundle(string name, int version = -1)
    {
        if (abContent.ContainsKey(name))
        {
            Data d = abContent[name];
            if (version == -1 || d.version == version)
            {
                return d.ab;
            }
        }

        return null;        
    }

    public void setAssetBundle(string name, AssetBundle ab, int version)
    {
        if (getAssetBundle(name, version) == null)
        {
            abContent.Add(name, new Data(ab, version));
        }
    }

    //todo:unload all
    //todo:unload single
}

AssetLoader的代码

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

#if UNITY_EDITOR || UNITY_STANDALONE
using System.IO;
#endif

public class AssetLoader
{
    protected class Data
    {
        public Data(string _key, int _version, List<string> _depends)
        {
            key = _key;
            depends = _depends;
            version = _version;
        }

        public string key { get; set; }
        public int version { get; set; }
        public List<string> depends { get; set; }
    }

    private string m_strWWWAssetPath = "http://ldr123.mobi/webAU/test/";
    private string m_strStandaloneAssetPath = "Res/";
    private delegate void wwwCallback (string name);    
    private delegate void downCallback ();
    
    private List<List<string>> m_downloadingRes = null;
    private List<string> m_processing = null;
    private MonoBehaviour m_mbHelper = null;
    public bool m_bReady = false;

    static Dictionary<string, Data> s_remoteFiles = new Dictionary<string, Data>();
    static Dictionary<string, Data> s_localFiles = new Dictionary<string, Data>();

    public AssetLoader (MonoBehaviour mb)
    {
        m_mbHelper = mb;
    }
    
#if UNITY_WEBPLAYER
    private IEnumerator webdownload(string filename, int version, wwwCallback callback)
    {
        while (!Caching.ready)
            yield return null;


        string assetPath = m_strWWWAssetPath + filename;
        WWW www = WWW.LoadFromCacheOrDownload(assetPath, version);
        yield return www;

        if (!string.IsNullOrEmpty(www.error))
        {
            yield return null;
        }
        else
        {
            AssetBundlePool.Instance().setAssetBundle(filename, www.assetBundle, version);
            www.Dispose();
            www = null;
        }

        if (callback != null)
        {
            callback(filename);
        }
    }
#endif

#if UNITY_EDITOR || UNITY_STANDALONE
    private IEnumerator standalonedownload(string filename, int version, wwwCallback callback)
    {
        string assetPath = m_strStandaloneAssetPath + filename;
        bool needDownload = true;
        FileInfo fi = new FileInfo(assetPath);
        if (fi.Exists)
        {
            if (s_localFiles.ContainsKey(filename))
            {
                if (s_localFiles[filename].version == version)
                {
                    needDownload = false;
                }
            }
        }

        if (needDownload)
        {
            string assetWWWPath = m_strWWWAssetPath + filename;
            WWW www = new WWW(assetWWWPath);
            yield return www;

            if (!string.IsNullOrEmpty(www.error))
            {
                yield return null;
            }
            else
            {
                if (File.Exists(assetPath))
                {
                    File.Delete(assetPath);
                }

                using (FileStream fsWrite = new FileStream(assetPath, FileMode.Create, FileAccess.Write))
                {
                    using (BinaryWriter bw = new BinaryWriter(fsWrite))
                    {
                        bw.Write(www.bytes);
                    }
                }

                if (s_localFiles.ContainsKey(filename))
                {
                    s_localFiles[filename].version = version;
                }
                else
                {
                    Data d = s_remoteFiles[filename];
                    s_localFiles.Add(filename, new Data(d.key, version, d.depends));
                }

                AssetBundlePool.Instance().setAssetBundle(filename, www.assetBundle, version);
                www.Dispose();
                www = null;
            }
        }

        if (callback != null)
        {
            callback(filename);
        }
    }
#endif

    private void download(string filename, wwwCallback callback)
    {
        if (!s_remoteFiles.ContainsKey(filename))
        {
            return;
        }

        int version = s_remoteFiles[filename].version;
        if (version == 0)
        {
            return;
        }

        if (AssetBundlePool.Instance().getAssetBundle(filename, version) != null)
        {
            if (callback != null)
            {
                callback(filename);
            }
        } 
        else
        {
#if UNITY_WEBPLAYER
                m_mbHelper.StartCoroutine(webdownload(filename, version, callback));
#elif UNITY_EDITOR || UNITY_STANDALONE
                m_mbHelper.StartCoroutine(standalonedownload(filename, version, callback));
#endif
        }     
    }
    
    private void www_callback (string name)
    {
        m_processing.Remove (name);

        //use ab
      //  AssetBundle ab = AssetBundlePool.Instance().getAssetBundle(name);
    }
    
    private IEnumerator startSubDownload (downCallback callback)
    {
        if (m_processing.Count > 0) {
            foreach (string x in m_processing) {
                download (x, www_callback);
            }
        }

        while (m_processing.Count != 0) {
            yield return null;
        }
        
        m_downloadingRes.RemoveAt (0);

        if (callback != null) {
            callback ();
        }
    }
    
    private void _startDownload ()
    {
        if (m_downloadingRes.Count == 0) {
            return;
        }

        m_processing = m_downloadingRes[0];
        m_mbHelper.StartCoroutine (startSubDownload (delegate() {
            _startDownload ();
        }));
    }
    
    public IEnumerator startDownload (List<List<string>> lst)
    {
        m_bReady = false;
        m_downloadingRes = lst;
        if (m_downloadingRes.Count > 0) {
            _startDownload ();

            while (m_downloadingRes.Count != 0) {
                yield return null;
            }
        }

        m_bReady = true;

    }
}

测试代码

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System.Collections.Generic;

public class load : MonoBehaviour
{
    public Button click;

    private AssetLoader dh = null;
    IEnumerator loadRes (List<List<string>> lst)
    {
        log("begin loadRes");
        StartCoroutine (dh.startDownload (lst));
        while (!dh.m_bReady) {
            yield return null;
        }

        click.gameObject.SetActive(true);
        log("end loadRes");
    }

    void Start ()
    {        
        dh = new AssetLoader(this);
        click.GetComponent<Button> ().onClick.AddListener (delegate() {
            this.Click (); 
        });
    }

    void Click ()
    {
        click.gameObject.SetActive(false);
        StartCoroutine(loadRes(new List<List<string>>()
        {
            new List<string> (){"a.ab", "b.ab", "c.ab"},
            new List<string> (){"00.ab"}
        }));
    }
}