devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

unity Assetbundle资源管理与更新比对下载_assetbundle如何替换更新

作者：知新_RL | 2024-02-16 08:43:07

赞

踩

assetbundle如何替换更新

在做项目时为了减少包体的大小，我们可以用unity自带的AssetBundle进行资源打包管理，本篇博客采用的方案是在资源打包时给每个资源一个特定的MD5值，写入文本进行保存资源名称和对应的MD5值，并把资源和存储的文本放入服务器中；然后本地运行项目时首先判断本地是否有已下载好的资源和文本，然后把本地的文本与服务器的文本进行比对，如果资源的MD5值不对应那么就下载此资源到本地进行替换同时更新相应的资源名和对应的MD5值；如果本地没有此资源也要重新下载资源到本地并把资源名和对应的MD5值下载到本地进行保存。

每次项目启动时首先进行资源比对看是否需要更新下载。
1.把已带有bundle名的资源build出来，打包资源的脚本放在Editor文件夹下: 

  1. using System.Collections.Generic;
  2. using UnityEngine;
  3. using UnityEditor;
  4. using System.IO;
  5. using System.Text;
  6. using System;
  7.  
  8. /// <summary>
  9. /// 把带有bundle名的资源build出来
  10. /// </summary>
  11. public class BuildAssetBundle : EditorWindow
  12. {
  13.     /// <summary>
  14.     /// 获取不同平台下的包裹存储路径
  15.     /// </summary>
  16.     public static string GetAssetBundlePath(BuildTarget target)
  17.     {
  18.         var path = PathConfig.buildAssetPath + "/" + PathConfig.GetBuildTargetPath(target) + "/";
  19.  
  20.         //当在硬盘目录结构里不存在该路径时,创建文件夹
  21.         if (!Directory.Exists(path))
  22.         {
  23.             Directory.CreateDirectory(path);
  24.         }
  25.         return path;
  26.     }
  27.  
  28.     [MenuItem("MrCAssetBundles/Build Windows")]
  29.     public static void CustomBuildAssetBundle_Win()
  30.     {
  31.         BuildBundle(BuildAssetBundleOptions.None, BuildTarget.StandaloneWindows);
  32.     }
  33.  
  34.     [MenuItem("MrCAssetBundles/Build IOS")]
  35.     public static void CustomBuildAssetBundle_IOS()
  36.     {
  37.         BuildBundle(BuildAssetBundleOptions.None, BuildTarget.iOS);
  38.     }
  39.  
  40.     [MenuItem("MrCAssetBundles/Build MAC")]
  41.     public static void CustomBuildAssetBundle_MAC()
  42.     {
  43.         BuildBundle(BuildAssetBundleOptions.None, BuildTarget.StandaloneOSX);
  44.     }
  45.  
  46.     [MenuItem("MrCAssetBundles/Build Android")]
  47.     public static void CustomBuildAssetBundle_Android()
  48.     {
  49.         BuildBundle(BuildAssetBundleOptions.None, BuildTarget.Android);
  50.     }
  51.  
  52.     [MenuItem("MrCAssetBundles/Build WebGL")]
  53.     public static void CustomBuildAssetBundle_WebGL()
  54.     {
  55.         BuildBundle(BuildAssetBundleOptions.None, BuildTarget.WebGL);
  56.     }
  57.  
  58.     private static void BuildBundle(BuildAssetBundleOptions bundleOptions, BuildTarget buildTarget)
  59.     {
  60.         //设置资源读取版本号
  61.  
  62.         //包裹存储的路径...
  63.         string outputPath = GetAssetBundlePath(EditorUserBuildSettings.activeBuildTarget);
  64.         if (!Directory.Exists(outputPath)) Directory.CreateDirectory(outputPath);
  65.         //打包过程..
  66.         BuildPipeline.BuildAssetBundles(outputPath, bundleOptions, buildTarget);
  67.         CreateVersion(outputPath);
  68.         Debug.Log("打包完成!位置: " + outputPath);
  69.  
  70.     }
  71.  
  72.  
  73.     #region MD5版本号
  74.  
  75.     public static void CreateVersion(string resPath)
  76.     {
  77.         // 获取Res文件夹下所有文件的相对路径和MD5值
  78.         string[] files = Directory.GetFiles(resPath, "*", SearchOption.AllDirectories);
  79.  
  80.         StringBuilder versions = new StringBuilder();
  81.         for (int i = 0, len = files.Length; i < len; i++)
  82.         {
  83.             string filePath = files[i];
  84.  
  85.             if (filePath.Contains("."))
  86.             {
  87.                 string extension = filePath.Substring(files[i].LastIndexOf("."));
  88.                 //只给后缀名为unity3d的文件生成MD5文件
  89.                 if (extension == ".unity3d")
  90.                 {
  91.                     string relativePath = filePath.Replace(resPath, "").Replace("\\", "/");
  92.                     string md5 = PathConfig.MD5File(filePath);
  93.                     versions.Append(relativePath).Append(",").Append(md5).Append("\r\n");
  94.                 }
  95.             }
  96.             else
  97.             {
  98.                 string test = filePath.Substring(files[i].LastIndexOf("/") + 1);
  99.                 if (test == PathConfig.GetBuildTargetPath(EditorUserBuildSettings.activeBuildTarget))
  100.                 {
  101.                     string relativePath = filePath.Replace(resPath, "").Replace("\\", "/");
  102.                     string md5 = PathConfig.MD5File(filePath);
  103.                     versions.Append(relativePath).Append(",").Append(md5).Append("\r\n");
  104.                 }
  105.             }
  106.         }
  107.  
  108.         // 生成配置文件
  109.         FileStream stream = new FileStream(resPath + PathConfig.version_file, FileMode.Create);
  110.  
  111.         byte[] data = Encoding.UTF8.GetBytes(versions.ToString());
  112.         stream.Write(data, 0, data.Length);
  113.         stream.Flush();
  114.         stream.Close();
  115.     }
  116.     #endregion
  117.  
  118.  
  119. }

2.资源build完成之后，后续更新比对，下载资源进行资源的加载

资源的路径管理脚本PathConfig:

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. #if UNITY_EDITOR
  5. using UnityEditor;
  6. #endif
  7.  
  8. /// <summary>
  9. /// 资源的路径管理脚本
  10. /// </summary>
  11. public class PathConfig
  12. {
  13.     //最大build加载数量
  14.     public static readonly int MAXBUNDLECOUNT = 5;
  15.  
  16.     public static readonly string bundleSuffix = ".unity3d";
  17.     //保存打包的资源名与对应的MD5值
  18.     public static readonly string version_file = "version.txt";
  19.     public static readonly string localUrl = Application.persistentDataPath;
  20.     //服务器下载资源地址
  21.     public static readonly string serverUrl = @"file:///D:/PHP/Apache2.2/htdocs/LuaScript/";
  22.     public static readonly string buildAssetPath = Application.streamingAssetsPath;
  23.  
  24.     //当前程序版本号(默认从1.0算起)
  25.     public static string ProductVersion = "Asset_1.0";
  26.  
  27.  
  28.     public static string GetFileHeader
  29.     {
  30.         get
  31.         {
  32. #if UNITY_EDITOR
  33.             return "file:///";
  34. #elif UNITY_IOS
  35.         return "";
  36. #elif UNITY_STANDALONE_OSX
  37.         return "";
  38. #elif UNITY_ANDROID
  39.         return "jar:file://";
  40. #elif UNITY_WEBGL
  41.         return "";
  42. #else
  43.         return "file:///";
  44. #endif
  45.         }
  46.     }
  47.  
  48.     public static string GetManifestFileName()
  49.     {
  50.         var version = ProductVersion;
  51. #if UNITY_EDITOR
  52.         return "Others/" + version;
  53. #elif UNITY_IOS
  54.         return "IOS/"+ version;
  55. #elif UNITY_STANDALONE_OSX
  56.         return "MacOS/"+ version;
  57. #elif UNITY_ANDROID
  58.         return "Android/"+ version;
  59. #elif UNITY_WEBGL
  60.         return "WebGL/"+ version;
  61. #else
  62.         return "Others/"+ version;
  63. #endif
  64.     }
  65.  
  66. #if UNITY_EDITOR
  67.     public static string GetBuildTargetPath(BuildTarget buildTarget)
  68.     {
  69.         var version = ProductVersion;
  70.         switch (buildTarget)
  71.         {
  72.             case BuildTarget.iOS:
  73.                 return "IOS/" + version;
  74.             case BuildTarget.StandaloneOSX:
  75.                 return "MacOS/" + version;
  76.             case BuildTarget.Android:
  77.                 return "Android/" + version;
  78.             case BuildTarget.WebGL:
  79.                 return "WebGL/" + version;
  80.             default:
  81.                 return "Others/" + version;
  82.         }
  83.     }
  84. #endif
  85.  
  86.     //检查url，如果末尾有'/'不处理，无添加
  87.     public static string CheckUrl(string url)
  88.     {
  89.         return url.Replace('\\', '/').TrimEnd('/') + '/';
  90.     }
  91.  
  92.     //生成MD5值
  93.     public static string MD5File(string file)
  94.     {
  95.         try
  96.         {
  97.             return MD5Checker.Check(file);
  98.         }
  99.         catch (System.Exception ex)
  100.         {
  101.             Debug.Log(ex.Message);
  102.             return string.Empty;
  103.         }
  104.     }
  105. }

生成MD5管理MD5类：

  1. using System;
  2. using System.IO;
  3. using System.Security.Cryptography;
  4.  
  5. /// <summary>
  6. /// 生成MD5管理MD5类
  7. /// </summary>
  8. public class MD5Checker
  9. {
  10.     public delegate void AsyncCheckHeadler(AsyncCheckEventArgs e);
  11.     public event AsyncCheckHeadler AsyncCheckProgress;
  12.  
  13.     //支持所有哈希算法
  14.     private HashAlgorithm hashAlgorithm;
  15.     //文件读取流
  16.     private Stream inputStream;
  17.     //缓存
  18.     private byte[] asyncBuffer;
  19.  
  20.     public AsyncCheckState CompleteState { get; private set; }
  21.     public float Progress { get; private set; }
  22.     public string GetMD5 { get; private set; }
  23.  
  24.     /// <summary>
  25.     /// 返回指定文件的MD5值
  26.     /// </summary>
  27.     /// <param name="path"></param>
  28.     /// <returns></returns>
  29.     public static string Check(string path)
  30.     {
  31.         try
  32.         {
  33.             var fs = new FileStream(path, FileMode.Open);
  34.             MD5CryptoServiceProvider md5Provider = new MD5CryptoServiceProvider();
  35.             byte[] buffer = md5Provider.ComputeHash(fs);
  36.             string resule = BitConverter.ToString(buffer);
  37.             resule = resule.Replace("-", "");
  38.             fs.Close();
  39.             return resule;
  40.         }
  41.         catch (ArgumentException aex)
  42.         {
  43.             throw new ArgumentException(string.Format("<{0}>, 不存在: {1}", path, aex.Message));
  44.         }
  45.         catch (Exception ex)
  46.         {
  47.             throw new Exception(string.Format("读取文件 {0} ,MD5失败: {1}", path, ex.Message));
  48.         }
  49.     }
  50.  
  51.     public static string Check_Stream(string path)
  52.     {
  53.         try
  54.         {
  55.             int bufferSize = 1024 * 256;//自定义缓冲区大小256K
  56.             var buffer = new byte[bufferSize];
  57.             Stream inputStream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);
  58.             HashAlgorithm hashAlgorithm = new MD5CryptoServiceProvider();
  59.             int readLength = 0;//每次读取长度
  60.             var output = new byte[bufferSize];
  61.             while ((readLength = inputStream.Read(buffer, 0, buffer.Length)) > 0)
  62.             {
  63.                 //计算MD5
  64.                 hashAlgorithm.TransformBlock(buffer, 0, readLength, output, 0);
  65.             }
  66.             //完成最后计算，必须调用(由于上一部循环已经完成所有运算，所以调用此方法时后面的两个参数都为0)
  67.             hashAlgorithm.TransformFinalBlock(buffer, 0, 0);
  68.             string md5 = BitConverter.ToString(hashAlgorithm.Hash);
  69.             hashAlgorithm.Clear();
  70.             inputStream.Close();
  71.             md5 = md5.Replace("-", "");
  72.             return md5;
  73.         }
  74.         catch (ArgumentException aex)
  75.         {
  76.             throw new ArgumentException(string.Format("<{0}>, 不存在: {1}", path, aex.Message));
  77.         }
  78.         catch (Exception ex)
  79.         {
  80.             throw new Exception(string.Format("读取文件 {0} ,MD5失败: {1}", path, ex.Message));
  81.         }
  82.     }
  83.  
  84.     public void AsyncCheck(string path)
  85.     {
  86.         CompleteState = AsyncCheckState.Checking;
  87.         try
  88.         {
  89.             int bufferSize = 1024 * 256;//缓冲区大小，1MB 1048576
  90.  
  91.             asyncBuffer = new byte[bufferSize];
  92.  
  93.             //打开文件流
  94.             inputStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.None, bufferSize, true);
  95.             hashAlgorithm = new MD5CryptoServiceProvider();
  96.  
  97.             //异步读取数据到缓冲区
  98.             inputStream.BeginRead(asyncBuffer, 0, asyncBuffer.Length, new AsyncCallback(AsyncComputeHashCallback), null);
  99.         }
  100.         catch (ArgumentException aex)
  101.         {
  102.             throw new ArgumentException(string.Format("<{0}>, 不存在: {1}", path, aex.Message));
  103.         }
  104.         catch (Exception ex)
  105.         {
  106.             throw new Exception(string.Format("读取文件{0} ,MD5失败: {1}", path, ex.Message));
  107.         }
  108.     }
  109.  
  110.     private void AsyncComputeHashCallback(IAsyncResult result)
  111.     {
  112.         int bytesRead = inputStream.EndRead(result);
  113.         //检查是否到达流末尾
  114.         if (inputStream.Position < inputStream.Length)
  115.         {
  116.             //输出进度
  117.             Progress = (float)inputStream.Position / inputStream.Length;
  118.             string pro = string.Format("{0:P0}", Progress);
  119.  
  120.             if (null != AsyncCheckProgress)
  121.                 AsyncCheckProgress(new AsyncCheckEventArgs(AsyncCheckState.Checking, pro));
  122.  
  123.             var output = new byte[asyncBuffer.Length];
  124.             //分块计算哈希值
  125.             hashAlgorithm.TransformBlock(asyncBuffer, 0, asyncBuffer.Length, output, 0);
  126.  
  127.             //异步读取下一分块
  128.             inputStream.BeginRead(asyncBuffer, 0, asyncBuffer.Length, new AsyncCallback(AsyncComputeHashCallback), null);
  129.             return;
  130.         }
  131.         else
  132.         {
  133.             //计算最后分块哈希值
  134.             hashAlgorithm.TransformFinalBlock(asyncBuffer, 0, bytesRead);
  135.         }
  136.  
  137.         Progress = 1;
  138.         string md5 = BitConverter.ToString(hashAlgorithm.Hash).Replace("-", "");
  139.         CompleteState = AsyncCheckState.Completed;
  140.         GetMD5 = md5;
  141.         if (null != AsyncCheckProgress)
  142.             AsyncCheckProgress(new AsyncCheckEventArgs(AsyncCheckState.Completed, GetMD5));
  143.  
  144.         inputStream.Close();
  145.     }
  146. }
  147.  
  148. public enum AsyncCheckState
  149. {
  150.     Completed,
  151.     Checking
  152. }
  153.  
  154. public class AsyncCheckEventArgs : EventArgs
  155. {
  156.     public string Value { get; private set; }
  157.  
  158.     public AsyncCheckState State { get; private set; }
  159.  
  160.     public AsyncCheckEventArgs(AsyncCheckState state, string value)
  161.     {
  162.         this.Value = value; this.State = state;
  163.     }
  164. }

3.Assetbundle自我管理的类:

MrCAssetBundle类管理bundle自身

  1. using UnityEngine;
  2.  
  3. /// <summary>
  4. /// MrCAssetBundle类管理bundle自身
  5. /// </summary>
  6. public sealed class MrCAssetBundle
  7.     {
  8.         internal string m_AssetBundleName;
  9.  
  10.         public AssetBundle AssetBundle { get; set; }
  11.  
  12.         public float Progress { get; set; }
  13.  
  14.         public bool IsDone { get; set; }
  15.  
  16.         internal MrCAssetBundle(string assetBundleName)
  17.         {
  18.             this.m_AssetBundleName = assetBundleName;
  19.             this.m_ReferencedCount = 1;
  20.         }
  21.  
  22.         private int m_ReferencedCount;
  23.  
  24.         //保留调用次数
  25.         public void RetainCall()
  26.         {
  27.             this.m_ReferencedCount++;
  28.         }
  29.  
  30.         //卸载资源
  31.         public void Release()
  32.         {
  33.             //this.m_ReferencedCount--;
  34.             当引用计数为0时，卸载资源
  35.             //if (this.m_ReferencedCount == 0)
  36.             //{
  37.             //    if(AssetBundle!=null)
  38.             //        this.AssetBundle.Unload(true);
  39.             //    MrCAssetCache.FreeBundle(this.m_AssetBundleName);
  40.             //}
  41.             if (AssetBundle != null)
  42.                 this.AssetBundle.Unload(true);
  43.             MrCAssetCache.FreeBundle(this.m_AssetBundleName);
  44.             Debug.Log("卸载资源: " + m_AssetBundleName);
  45.         }
  46.  
  47.         //如果是新创建的，不首先消毁
  48.         public int RetainCount()
  49.         {
  50.             var newbundle = MrCAssetManager.Instance.NewAssetBundle;
  51.             if (newbundle != null && newbundle == this)
  52.             {
  53.                 return 65535;
  54.             }
  55.             return m_ReferencedCount;
  56.         }
  57.     }

MrCAssetCache类缓存bundle:

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. /// <summary>
  6. /// MrCAssetCache类缓存bundle
  7. /// </summary>
  8. internal sealed class MrCAssetCache                      //缓存管理
  9. {
  10.     #region 包裹缓存机制
  11.     //创建缓存字典
  12.     private static Dictionary<string, MrCAssetBundle> assetBundleCache;
  13.     //缓存字典属性
  14.     internal static Dictionary<string, MrCAssetBundle> AssetBundleCache
  15.     {
  16.         get
  17.         {
  18.             if (assetBundleCache == null)
  19.             {
  20.                 assetBundleCache = new Dictionary<string, MrCAssetBundle>();
  21.             }
  22.             return assetBundleCache;
  23.         }
  24.     }
  25.  
  26.     //创建缓存WWW对象
  27.     private static Dictionary<string, AssetBundleCreateRequest> wwwCache;
  28.     //创建缓存WWW对象属性
  29.     private static Dictionary<string, AssetBundleCreateRequest> WwwCache
  30.     {
  31.         get
  32.         {
  33.             if (wwwCache == null)
  34.             {
  35.                 wwwCache = new Dictionary<string, AssetBundleCreateRequest>();
  36.             }
  37.             return wwwCache;
  38.         }
  39.     }
  40.  
  41.     //创建依赖缓存对象
  42.     private static Dictionary<string, string[]> dependCache;
  43.     //创建依赖缓存属性
  44.     private static Dictionary<string, string[]> DependCache
  45.     {
  46.         get
  47.         {
  48.             if (dependCache == null)
  49.             {
  50.                 dependCache = new Dictionary<string, string[]>();
  51.             }
  52.             return dependCache;
  53.         }
  54.     }
  55.  
  56.  
  57.     /// <summary>
  58.     /// Instantiate the Cache
  59.     /// </summary>
  60.     /// <param name="assetbundleName"></param>
  61.     /// <returns></returns>
  62.     internal static bool InCache(string assetbundleName)
  63.     {
  64.         return AssetBundleCache.ContainsKey(assetbundleName);
  65.     }
  66.     #endregion
  67.  
  68.  
  69.  
  70.     #region 卸载系列函数
  71.  
  72.     /// <summary>
  73.     /// 卸载资源包和依赖包
  74.     /// </summary>
  75.     /// <param name="assetBundleName"></param>
  76.     public static void UnloadAssetBundle(string assetBundleName)
  77.     {
  78.         UnloadAssetBundleInternal(assetBundleName);
  79.         UnloadDependencies(assetBundleName);
  80.     }
  81.  
  82.     internal static void UnloadDependencies(string assetBundleName)
  83.     {
  84.         string[] depends = null;
  85.  
  86.         //获取所有的依赖包名称
  87.         if (!DependCache.TryGetValue(assetBundleName, out depends))
  88.             return;
  89.  
  90.         //卸载依赖包
  91.         foreach (var dependency in depends)
  92.         {
  93.             UnloadAssetBundleInternal(dependency);
  94.         }
  95.         //删除依赖缓存策略
  96.         DependCache.Remove(assetBundleName);
  97.     }
  98.  
  99.     internal static void UnloadAssetBundleInternal(string assetBundleName)
  100.     {
  101.         MrCAssetBundle bundle;
  102.         AssetBundleCache.TryGetValue(assetBundleName, out bundle);
  103.  
  104.         if (bundle == null)
  105.             return;
  106.         bundle.Release();
  107.     }
  108.     #endregion
  109.  
  110.     #region GetFunction
  111.     internal static AssetBundleCreateRequest GetWWWCache(string key)
  112.     {
  113.         if (WwwCache.ContainsKey(key))
  114.         {
  115.             return WwwCache[key];
  116.         }
  117.         return null;
  118.     }
  119.     internal static MrCAssetBundle SetWWWCache(string key, AssetBundleCreateRequest value)
  120.     {
  121.         if (!WwwCache.ContainsKey(key))
  122.             WwwCache.Add(key, value);
  123.         else
  124.             WwwCache[key] = value;
  125.         var bundleObject = new MrCAssetBundle(key);
  126.         SetBundleCache(key, bundleObject);
  127.         return bundleObject;
  128.     }
  129.  
  130.     internal static MrCAssetBundle GetBundleCache(string key)
  131.     {
  132.         MrCAssetBundle ab;
  133.         AssetBundleCache.TryGetValue(key, out ab);
  134.         return ab;
  135.     }
  136.  
  137.     internal static void SetBundleCache(string key, MrCAssetBundle value)
  138.     {
  139.         if (!AssetBundleCache.ContainsKey(key))
  140.         {
  141.             AssetBundleCache.Add(key, value);
  142.         }
  143.         else
  144.         {
  145.             AssetBundleCache[key] = value;
  146.         }
  147.     }
  148.  
  149.     internal static string[] GetDependCache(string key)
  150.     {
  151.         string[] depends;
  152.         DependCache.TryGetValue(key, out depends);
  153.         return depends;
  154.     }
  155.     internal static void SetDependCache(string key, string[] value)
  156.     {
  157.         if (!DependCache.ContainsKey(key))
  158.         {
  159.             DependCache.Add(key, value);
  160.         }
  161.     }
  162.     #endregion
  163.  
  164.     internal static void FreeBundle(string key)
  165.     {
  166.         if (AssetBundleCache.ContainsKey(key))
  167.             AssetBundleCache.Remove(key);
  168.     }
  169.  
  170.     #region Update
  171.     private static List<string> keysToRemove = new List<string>();
  172.  
  173.     internal static void Update()
  174.     {
  175.         foreach (var keyValue in WwwCache)
  176.         {
  177.             var download = keyValue.Value;
  178.             string bundleName = keyValue.Key;
  179.  
  180.             var bundleObject = GetBundleCache(bundleName);
  181.             if (bundleObject == null)
  182.             {
  183.                 bundleObject = new MrCAssetBundle(bundleName);
  184.                 SetBundleCache(bundleName, bundleObject);
  185.             }
  186.  
  187.             bundleObject.Progress = download.progress;
  188.  
  189.             //下载成功
  190.             if (download.isDone)
  191.             {
  192.                 bundleObject.AssetBundle = download.assetBundle;
  193.                 bundleObject.IsDone = true;
  194.                 bundleObject.Progress = 1.1f;
  195.                 keysToRemove.Add(bundleName);
  196.             }
  197.         }
  198.  
  199.         //删除下载成功的WWW对象
  200.         foreach (var key in keysToRemove)
  201.         {
  202.             if (wwwCache.ContainsKey(key))
  203.             {
  204.                 var download = WwwCache[key];
  205.                 WwwCache.Remove(key);
  206.             }
  207.         }
  208.         keysToRemove.Clear();
  209.     }
  210.     #endregion
  211. }

MrCAssetManager类:

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. //AssetBundle管理
  6. public class MrCAssetManager : MonoBehaviour
  7. {
  8.     #region Singleton
  9.     private static MrCAssetManager _instance = null;
  10.  
  11.     public static MrCAssetManager Instance
  12.     {
  13.         get
  14.         {
  15.             if (_instance == null)
  16.             {
  17.                 var obj = new GameObject("LoadAssetManager");
  18.                 _instance = obj.AddComponent<MrCAssetManager>();
  19.             }
  20.             return _instance;
  21.         }
  22.     }
  23.  
  24.     #endregion
  25.  
  26.     //最新生成的bundle
  27.     public MrCAssetBundle NewAssetBundle { get; set; }
  28.  
  29.     public void Init()
  30.     {
  31.         StartCoroutine(LoadManifestBundle());
  32.     }
  33.  
  34.  
  35.     // 异步加载场景
  36.     public IEnumerator LoadLevelAsync(string assetBundleName, string assetName)
  37.     {
  38.         var bundleObject = MrCAssetCache.GetBundleCache(assetBundleName);
  39.         //缓存中已经存在请求bundle，中止..
  40.         if (bundleObject == null)
  41.         {
  42.             //通过网络下载AssetBundle
  43.             bundleObject = LoadAssetBundleAtInternal(assetBundleName);
  44.             yield return LoadAssetBundleProgress(bundleObject);
  45.             //StartCoroutine(LoadDependencies(assetBundleName));
  46.         }
  47.         else
  48.         {
  49.             bundleObject.RetainCall();
  50.         }
  51.     }
  52.  
  53.     private void Update()
  54.     {
  55.         MrCAssetCache.Update();
  56.     }
  57.  
  58.     public IEnumerator LoadManifestBundle()
  59.     {
  60.         var manifestName = PathConfig.GetManifestFileName();
  61.  
  62.         var bundleObject = MrCAssetCache.GetBundleCache(manifestName);
  63.         //缓存中已经存在请求bundle，中止..
  64.         if (bundleObject == null)
  65.         {
  66.             //通过网络下载AssetBundle
  67.             bundleObject = LoadAssetBundleAtInternal(manifestName);
  68.             yield return LoadAssetBundleProgress(bundleObject);
  69.         }
  70.         else
  71.         {
  72.             bundleObject.RetainCall();
  73.         }
  74.     }
  75.  
  76.     #region 加载包裹系列函数
  77.  
  78.     ///检查是否已经从网络下载
  79.     protected MrCAssetBundle LoadAssetBundleAtInternal(string assetBundleName)
  80.     {
  81.         var bundleObject = MrCAssetCache.GetBundleCache(assetBundleName);
  82.         //如果WWW缓存策略中包含有对应的关键字，则返回true
  83.         if (bundleObject == null)
  84.         {
  85.             MustBundleHandle();
  86.  
  87.             var url = PathConfig.localUrl + "/"
  88.                 + PathConfig.GetManifestFileName() + "/"
  89.                 + assetBundleName;
  90.             //创建下载链接
  91.             var request = AssetBundle.LoadFromFileAsync(url);
  92.             //加入缓存策略
  93.             NewAssetBundle = MrCAssetCache.SetWWWCache(assetBundleName, request);
  94.             return NewAssetBundle;
  95.         }
  96.         return bundleObject;
  97.     }
  98.  
  99.     //超过最大bunld数处理
  100.     private void MustBundleHandle()
  101.     {
  102.         var bundles = MrCAssetCache.AssetBundleCache;
  103.         if (bundles != null && bundles.Count >= PathConfig.MAXBUNDLECOUNT)
  104.         {
  105.             int min = int.MaxValue;
  106.             string findKey = string.Empty;
  107.             foreach (var item in bundles.Values)
  108.             {
  109.                 if (item.RetainCount() < min)
  110.                 {
  111.                     min = item.RetainCount();
  112.                     findKey = item.m_AssetBundleName;
  113.                 }
  114.             }
  115.             var bundle = MrCAssetCache.GetBundleCache(findKey);
  116.             if (bundle != null) bundle.Release();
  117.         }
  118.     }
  119.  
  120.     public IEnumerator LoadDependencies(string assetBundleName)
  121.     {
  122.         var manifestName = PathConfig.GetManifestFileName();
  123.         var manifest = this.GetAsset<AssetBundleManifest>(manifestName, "AssetBundleManifest");
  124.         if (manifest == null)
  125.         {
  126.             if (MrCAssetCache.InCache(manifestName))
  127.             {
  128.                 manifest = this.GetAsset<AssetBundleManifest>(manifestName, "AssetBundleManifest");
  129.             }
  130.             else
  131.                 yield return null;
  132.         }
  133.  
  134.         //获取依赖包裹
  135.         string[] depends = manifest.GetAllDependencies(assetBundleName);
  136.  
  137.         if (depends.Length == 0)
  138.         {
  139.             yield return null;
  140.         }
  141.  
  142.         //记录并且加载所有的依赖包裹
  143.         MrCAssetCache.SetDependCache(assetBundleName, depends);
  144.  
  145.         for (int i = 0; i < depends.Length; i++)
  146.         {
  147.             yield return LoadAssetBundleAtInternal(depends[i]);
  148.         }
  149.     }
  150.  
  151.     /// <summary>
  152.     /// 用于加载资源
  153.     /// </summary>
  154.     /// <typeparam name="T"></typeparam>
  155.     /// <param name="assetbundleName"></param>
  156.     /// <param name="assetName"></param>
  157.     /// <returns></returns>
  158.     public T GetAsset<T>(string assetbundleName, string assetName) where T : UnityEngine.Object
  159.     {
  160.         MrCAssetBundle lab = MrCAssetCache.GetBundleCache(assetbundleName);
  161.         if (lab != null)
  162.         {
  163.             return lab.AssetBundle.LoadAsset<T>(assetName);
  164.         }
  165.         else
  166.         {
  167.             print("资源: " + assetbundleName + " 未加载或正在加载!");
  168.             return null;
  169.         }
  170.     }
  171.     #endregion
  172.  
  173.     #region  Loading阶段
  174.     private IEnumerator LoadAssetBundleProgress(MrCAssetBundle _bundleObject)
  175.     {
  176.         if (_bundleObject == null)
  177.         {
  178.             yield break;
  179.         }
  180.         //当前进度
  181.         //int initNum = 0;
  182.         //目标进度
  183.         //int maxNum = 2000;
  184.         while (!_bundleObject.IsDone)
  185.         {
  186.             yield return new WaitForEndOfFrame();
  187.         }
  188.     }
  189.     #endregion
  190. }

UpdateAssets类：负责比对更新下载

  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.IO;
  5. using System.Linq;
  6. using System.Text;
  7. using UnityEngine;
  8. using UnityEngine.Networking;
  9.  
  10. public class UpdateAssets : MonoBehaviour
  11. {
  12.     //保存本地的assetbundle名和对应的MD5值
  13.     private Dictionary<string, string> LocalResVersion;
  14.     private Dictionary<string, string> ServerResVersion;
  15.  
  16.     //保存需要更新的AssetBundle名
  17.     private List<string> NeedDownFiles;
  18.     //是否需要下载文件
  19.     private bool NeedUpdateLocalVersionFile = false;
  20.  
  21.     private string _localUrl;
  22.     private string _serverUrl;
  23.  
  24.     public IEnumerator OnStart()
  25.     {
  26.         yield return Init();
  27.     }
  28.  
  29.     private IEnumerator Init()
  30.     {
  31.         LocalResVersion = new Dictionary<string, string>();
  32.         ServerResVersion = new Dictionary<string, string>();
  33.         NeedDownFiles = new List<string>();
  34.  
  35.         //加载本地version配置
  36.         _localUrl = PathConfig.localUrl + "/" + PathConfig.GetManifestFileName() + "/";
  37.         Debug.Log(PathConfig.GetFileHeader + _localUrl);
  38.         yield return DownLoad(PathConfig.GetFileHeader + _localUrl, PathConfig.version_file, LocalVersionCallBack);
  39.  
  40.  
  41.         //加载服务端version配置
  42.         var serverUrl = PathConfig.serverUrl;
  43.         _serverUrl = serverUrl + PathConfig.GetManifestFileName() + "/";
  44.         Debug.Log("下载文件服务器: " + _serverUrl);
  45.         yield return DownLoad(_serverUrl, PathConfig.version_file, ServerVersionCallBack);
  46.     }
  47.  
  48.     /// <summary>
  49.     /// 下载本地版本的回调
  50.     /// </summary>
  51.     /// <param name="request"></param>
  52.     /// <param name="param"></param>
  53.     /// <returns></returns>
  54.     private IEnumerator LocalVersionCallBack(UnityWebRequest request, string param = "")
  55.     {
  56.         Debug.Log("本地下载");
  57.         //保存本地的version
  58.         var context = request.downloadHandler.text;
  59.         ParseVersionFile(context, LocalResVersion);
  60.  
  61.         yield return ClearIncompleteFile();
  62.     }
  63.  
  64.     /// <summary>
  65.     /// 下载服务器版本的回调
  66.     /// </summary>
  67.     /// <param name="request"></param>
  68.     /// <param name="param"></param>
  69.     /// <returns></returns>
  70.     private IEnumerator ServerVersionCallBack(UnityWebRequest request, string param = "")
  71.     {
  72.         Debug.Log("服务器下载");
  73.         //保存服务端version
  74.         var context = request.downloadHandler.text;
  75.         ParseVersionFile(context, ServerResVersion);
  76.  
  77.         //根据用户名过滤下载资源
  78.         //FilterServerDownLoadFile();
  79.  
  80.         //计算出需要重新加载的资源
  81.         CompareVersion();
  82.         if (NeedUpdateLocalVersionFile)
  83.         {
  84.             //DownLoadProgress.Instance.ShowDownLoad(NeedDownFiles.Count);
  85.             Debug.Log("需要更新的资源个数为：" + NeedDownFiles.Count);
  86.         }
  87.         //加载需要更新的资源
  88.         yield return DownLoadRes();
  89.     }
  90.  
  91.     //对比本地配置，清除缺失文件
  92.     private IEnumerator ClearIncompleteFile()
  93.     {
  94.         if (LocalResVersion != null)
  95.         {
  96.             List<string> removeKey = new List<string>();
  97.             foreach (var local in LocalResVersion)
  98.             {
  99.                 string filePath = _localUrl + local.Key;
  100.                 if (!Directory.Exists(_localUrl))
  101.                 {
  102.                     Directory.CreateDirectory(_localUrl);
  103.                 }
  104.                 if (!File.Exists(filePath))
  105.                 {
  106.                     removeKey.Add(local.Key);
  107.                 }
  108.                 else
  109.                 {
  110.                     //异步
  111.                     yield return MD5FileAsync(filePath, delegate (string md5)
  112.                     {
  113.                         if (md5 != local.Value)
  114.                         {
  115.                             File.Delete(filePath);
  116.                             removeKey.Add(local.Key);
  117.                         }
  118.                     });
  119.  
  120.                 }
  121.             }
  122.             foreach (var key in removeKey)
  123.             {
  124.                 if (LocalResVersion.ContainsKey(key))
  125.                     LocalResVersion.Remove(key);
  126.             }
  127.         }
  128.     }
  129.  
  130.  
  131.     //依次加载需要更新的资源
  132.     private IEnumerator DownLoadRes()
  133.     {
  134.         if (NeedDownFiles.Count == 0)
  135.         {
  136.             UpdateLocalVersionFile();
  137.             yield break;
  138.         }
  139.  
  140.         string file = NeedDownFiles[0];
  141.  
  142.         NeedDownFiles.RemoveAt(0);
  143.         yield return DownLoad(_serverUrl, file, DownLoadCallBack);
  144.     }
  145.  
  146.     /// <summary>
  147.     /// 下载需要更新的文件
  148.     /// </summary>
  149.     /// <param name="request"></param>
  150.     /// <param name="param"></param>
  151.     /// <returns></returns>
  152.     private IEnumerator DownLoadCallBack(UnityWebRequest request, string param = "")
  153.     {
  154.         Debug.Log("下载需要更新的资源");
  155.         //将下载的资源替换本地就的资源
  156.         var download = request.downloadHandler;
  157.         if (!request.isNetworkError && !request.isHttpError)
  158.         {
  159.             ReplaceLocalRes(param, download.data);
  160.             if (ServerResVersion.ContainsKey(param))
  161.             {
  162.                 if (LocalResVersion.ContainsKey(param))
  163.                     LocalResVersion[param] = ServerResVersion[param];
  164.                 else
  165.                     LocalResVersion.Add(param, ServerResVersion[param]);
  166.             }
  167.         }
  168.         yield return DownLoadRes();
  169.     }
  170.  
  171.     /// <summary>
  172.     /// 替换本地的资源文件
  173.     /// </summary>
  174.     /// <param name="fileName"></param>
  175.     /// <param name="data"></param>
  176.     private void ReplaceLocalRes(string fileName, byte[] data)
  177.     {
  178.         string filePath = _localUrl + fileName;
  179.  
  180.         if (!Directory.Exists(_localUrl))
  181.         {
  182.             Directory.CreateDirectory(_localUrl);
  183.         }
  184.         FileStream stream = new FileStream(filePath, FileMode.Create);
  185.         stream.Write(data, 0, data.Length);
  186.         stream.Flush();
  187.         stream.Close();
  188.     }
  189.  
  190.  
  191.     //更新本地的version配置
  192.  
  193.     private void UpdateLocalVersionFile()
  194.     {
  195.         if (NeedUpdateLocalVersionFile)
  196.         {
  197.             StringBuilder versions = new StringBuilder();
  198.             foreach (var item in LocalResVersion)
  199.             {
  200.                 versions.Append(item.Key).Append(",").Append(item.Value).Append("\r\n");
  201.             }
  202.             if (!Directory.Exists(_localUrl))
  203.             {
  204.                 Directory.CreateDirectory(_localUrl);
  205.             }
  206.             FileStream stream = new FileStream(_localUrl + PathConfig.version_file, FileMode.Create);
  207.             byte[] data = Encoding.UTF8.GetBytes(versions.ToString());
  208.             stream.Write(data, 0, data.Length);
  209.             stream.Flush();
  210.             stream.Close();
  211.         }
  212.  
  213.         //加载显示对象
  214.         //StartCoroutine(Show());
  215.     }
  216.  
  217.     /// <summary>
  218.     /// 计算出需要更新的文件
  219.     /// </summary>
  220.     private void CompareVersion()
  221.     {
  222.         foreach (var version in ServerResVersion)
  223.         {
  224.             string fileName = version.Key;                 //assetbundleName
  225.             string serverMd5 = version.Value;              // asset MD5值
  226.  
  227.             //新增的资源
  228.             if (!LocalResVersion.ContainsKey(fileName))
  229.             {
  230.                 NeedDownFiles.Add(fileName);
  231.             }
  232.             else
  233.             {
  234.                 //需要替换的资源
  235.                 string localMd5;
  236.  
  237.                 LocalResVersion.TryGetValue(fileName, out localMd5);
  238.                 if (!serverMd5.Equals(localMd5))
  239.                 {
  240.                     NeedDownFiles.Add(fileName);
  241.                 }
  242.             }
  243.         }
  244.  
  245.         if (NeedDownFiles.Count > 0)
  246.         {
  247.             for (int i = 0; i < NeedDownFiles.Count; i++)
  248.             {
  249.                 Debug.Log("需要更新的资源：" + NeedDownFiles[i]);
  250.             }
  251.         }
  252.         //本次有更新，同时更新本地的version.txt
  253.         NeedUpdateLocalVersionFile = NeedDownFiles.Count > 0;
  254.     }
  255.  
  256.     /// <summary>
  257.     /// 解析版本文件
  258.     /// </summary>
  259.     /// <param name="content"></param>
  260.     /// <param name="dict"></param>
  261.     private void ParseVersionFile(string content, Dictionary<string, string> dict)
  262.     {
  263.         if (content == null || content.Length == 0)
  264.         {
  265.             return;
  266.         }
  267.  
  268.         string[] items = content.Split('\n');
  269.         foreach (string item in items)
  270.         {
  271.             string str = item.Replace("\r", "").Replace("\n", "").Replace(" ", "");
  272.             string[] info = str.Split(',');
  273.             if (info != null && info.Length == 2)
  274.             {
  275.                 dict.Add(info[0], info[1]);
  276.             }
  277.         }
  278.     }
  279.  
  280.     /// <summary>
  281.     /// 下载文件
  282.     /// </summary>
  283.     /// <param name="url"></param>
  284.     /// <param name="fileName"></param>
  285.     /// <param name="finishFun"></param>
  286.     /// <returns></returns>
  287.     private IEnumerator DownLoad(string url, string fileName, HandleFinishDownload finishFun)
  288.     {
  289.         url = PathConfig.CheckUrl(url);
  290.         var request = UnityWebRequest.Get(url + fileName);
  291.         if (NeedUpdateLocalVersionFile)
  292.         {
  293.             yield return LoadRegularRequest(request);
  294.         }
  295.         else
  296.         {
  297.             yield return request.SendWebRequest();
  298.         }
  299.  
  300.         if (finishFun != null && request.isDone)
  301.         {
  302.             yield return finishFun(request, fileName);
  303.         }
  304.         if (request.isNetworkError)
  305.         {
  306.             Debug.LogError("更新资源出错: " + url + " error: " + request.error);
  307.         }
  308.         request.Dispose();
  309.     }
  310.  
  311.     public delegate IEnumerator HandleFinishDownload(UnityWebRequest request, string param = "");
  312.  
  313.  
  314.     //异步生成MD5值
  315.     private IEnumerator MD5FileAsync(string file, Action<string> action)
  316.     {
  317.         var asyncChecker = new MD5Checker();
  318.         asyncChecker.AsyncCheck(file);
  319.         var endframe = new WaitForEndOfFrame();
  320.         while (asyncChecker.CompleteState == AsyncCheckState.Checking)
  321.         {
  322.             //SeerLogger.Log("load...{0:P0}" + asyncChecker.Progress);
  323.             yield return endframe;
  324.         }
  325.         action(asyncChecker.GetMD5);
  326.     }
  327.  
  328.     //整齐的下载资源
  329.     public IEnumerator LoadRegularRequest(UnityEngine.Networking.UnityWebRequest request)
  330.     {
  331.         var ao = request.SendWebRequest();
  332.         bool downError = false;
  333.         //ao.allowSceneActivation = false;
  334.         while (true)
  335.         {
  336.             if (downError) break;
  337.  
  338.             if (ao.webRequest.isNetworkError || ao.webRequest.isHttpError)
  339.             {
  340.                 downError = true;
  341.             }
  342.             else if (ao.isDone)
  343.                 break;
  344.         }
  345.         yield return new WaitForEndOfFrame();
  346.     }
  347.     //ao.allowSceneActivation = true;
  348.  
  349. }
  350.

最后是我们自己的测试登陆：TestManager类：

  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using UnityEngine;
  5. using XLua;
  6.  
  7. public class TestManager : MonoBehaviour
  8. {
  9.     private static TestManager _instance;
  10.     public UpdateAssets updateAssets;
  11.  
  12.     private void Awake()
  13.     {
  14.         if (_instance == null)
  15.         {
  16.             _instance = this;
  17.         }
  18.     }
  19.     public static TestManager Instance
  20.     {
  21.         get { return _instance; }
  22.     }
  23.     public bool IsBundleSuccess { get; set; }
  24.  
  25.     void Start()
  26.     {
  27.         StartCoroutine(InitUpdate(LoadGameObject));
  28.     }
  29.  
  30.     private IEnumerator InitUpdate(Action action)
  31.     {
  32.         if (updateAssets)
  33.         {
  34.             yield return updateAssets.OnStart();
  35.         }
  36.  
  37.         if (action != null)
  38.         {
  39.             action();
  40.         }
  41.     }
  42.  
  43.     /// <summary>
  44.     /// 加载游戏对象
  45.     /// </summary>
  46.     public void LoadGameObject()
  47.     {
  48.         StartCoroutine(LoadGameObjectCoroutine("test1.unity3d", "Cube",null));
  49.     }
  50.  
  51.     public IEnumerator LoadGameObjectCoroutine(string gameObjectName, string assetName, Action action)
  52.     {
  53.         yield return MrCAssetManager.Instance.LoadLevelAsync(gameObjectName, assetName);
  54.         GameObject go = MrCAssetManager.Instance.GetAsset<GameObject>(gameObjectName, assetName);
  55.         Instantiate(go);
  56.  
  57.         LuaEnv luaEnv = new LuaEnv();
  58.         TextAsset txtAsset = MrCAssetManager.Instance.GetAsset<TextAsset>(gameObjectName,"1.lua");
  59.         luaEnv.DoString(txtAsset.text);
  60.         luaEnv.Dispose();
  61.     }
  62.  
  63. }

这里的测试类和大神的测试类有点不一样，不懂了再去看大神的。

以上就是assetbundle打包到比对更新，下载资源，解压应用的整套流程。浏览之前最好对unity  Assetbundle的打包流程到应用有所了解之后再结合应用到自己的项目中。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/92048
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号