Unity AssetBundle打包之存储Hash

具体代码如下 注释代码中都有自行查看

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

public class BuildEditor : EditorWindow
{
#if UNITY_ANDROID
    static string m_CurPlatformName = "Android";
#elif UNITY_IOS
    static string m_CurPlatformName = "IOS";
#else
    static string m_CurPlatformName = "Windows";
#endif
    /// <summary>
    /// 资源打包路径
    /// </summary>
    private static string m_OutPath = Application.dataPath + "/GameRes";
    /// <summary>
    /// 当前选择的平台
    /// </summary>
    private static BuildTarget m_BuildTarget = EditorUserBuildSettings.activeBuildTarget;
    /// <summary>
    /// 资源输出路径
    /// </summary>
    private static string m_BundlePutPath = Application.streamingAssetsPath + "/" + m_CurPlatformName + "/AssetBundles";
    /// <summary>
    /// 打包列表
    /// </summary>
    private static List<string> finalFiles = new List<string>();
    /// <summary>
    /// 打包完成之后生成的Manifest文件
    /// </summary>
    private static AssetBundleManifest m_Manifest;
    /// <summary>
    /// 打包
    /// </summary>
    [MenuItem("Build/Build ab")]
    private static void Build()
    {
        finalFiles.Clear();
        //1.清除AssetBundleName
        ClearAssetBundleName();
        //2.设置AssetBundleName
        Pack(m_OutPath);
        //3.打包
        if (Directory.Exists(m_BundlePutPath)) Directory.Delete(m_BundlePutPath, true);
        string tempFilePath = m_BundlePutPath;
        Directory.CreateDirectory(m_BundlePutPath);
        m_Manifest = BuildPipeline.BuildAssetBundles(m_BundlePutPath, BuildAssetBundleOptions.DeterministicAssetBundle, m_BuildTarget);
        if (m_Manifest != null)
        {
            DeleteManifestFile(m_BundlePutPath);
            CreateFileList();
            Util.BuildSuccessOrFail("Build AB", "Build Succeed", "OK");
        }
        else
        {
            Util.BuildSuccessOrFail("Build AB", "Build Fail", "OK");
        }
        EditorUtility.ClearProgressBar();
        AssetDatabase.Refresh();
        Debug.Log("Build Succeed !!!");
    }
    /// <summary>
    /// 清除AssetBundle
    /// </summary>
    public static void ClearAssetBundleName()
    {
        string[] strs = AssetDatabase.GetAllAssetBundleNames();
        foreach (var bundleName in strs)
        {
            AssetDatabase.RemoveAssetBundleName(bundleName, true);
        }
        AssetDatabase.Refresh();
    }
    /// <summary>
    /// 检查文件
    /// </summary>
    /// <param name="path"></param>
    private static void Pack(string path)
    {
        DirectoryInfo infos = new DirectoryInfo(path);
        FileSystemInfo[] files = infos.GetFileSystemInfos();
        for (int i = 0; i < files.Length; i++)
        {
            if (files[i] is DirectoryInfo)
            {
                Pack(files[i].FullName);
            }
            else
            {
                if (!files[i].FullName.EndsWith(".meta"))
                {
                    SetAssetBundleName(files[i].FullName);
                }
            }
        }
    }

    /// <summary>
    /// 删除掉当前路径下所有.Manifest文件
    /// </summary>
    /// <param name="path"></param>
    private static void DeleteManifestFile(string path)
    {
        DirectoryInfo infos = new DirectoryInfo(path);
        FileSystemInfo[] files = infos.GetFileSystemInfos();
        for (int i = 0; i < files.Length; i++)
        {
            if (files[i] is DirectoryInfo)
            {
                DeleteManifestFile(files[i].FullName);
            }
            else
            {
                if (files[i].FullName.EndsWith(".manifest"))
                {
                    File.Delete(files[i].FullName);
                }
            }
        }
    }

    /// <summary>
    /// 设置AssetBundleName
    /// </summary>
    /// <param name="source"></param>
    private static void SetAssetBundleName(string source)
    {
        string _source = source.Replace(@"\\", "/");
        //截取完整路径到Assets/位置获得Assets路径
        string _assetPath1 = "Assets" + _source.Substring(Application.dataPath.Length);
        //获取Assets/之后的路径 以方便做AssetBunndleName使用
        string _assetPath2 = _source.Substring(Application.dataPath.Length + 1);
        //获取Assets路径下的文件
        AssetImporter assetImporter = AssetImporter.GetAtPath(_assetPath1);
        //获取AssetBundleName
        string bundleName = _assetPath2;
        //获取文件的扩展名并将其替换成.assetbundle
        bundleName = bundleName.Replace(Path.GetExtension(bundleName), ".assetbundle");
        //设置Bundle名
        assetImporter.assetBundleName = bundleName;
        //获取每个文件的指定路径并添加到列表里以方便写file文件使用
        string newFilePath = m_BundlePutPath + PathUtils.GetRelativePath(source, Application.dataPath, "").ToLower();
        string[] strs = newFilePath.Split('.');
        finalFiles.Add(strs[0] + ".assetbundle");
    }

    /// <summary>
    /// 生成 file 文件
    /// </summary>
    static void CreateFileList()
    {
        //files文件 目标路径
        string targetFilePath = m_BundlePutPath + "/files.txt";
        //检查是否存在该文件 存在则删除
        if (File.Exists(targetFilePath))
            File.Delete(targetFilePath);
        //统计大小 单位B
        long totalFileSize = 0;
        FileStream fs = new FileStream(targetFilePath, FileMode.CreateNew);
        StreamWriter sw = new StreamWriter(fs);
        int count = 0;
        string file;
        finalFiles.Add(m_BundlePutPath + "/AssetBundles");
        File.Delete(m_BundlePutPath + "/AssetBundles.manifest");
        m_BundlePutPath = m_BundlePutPath.Replace('\\', '/');
        foreach (var files in finalFiles)
        {
            file = PathUtils.NormalizePath(files);
            count++;
            Util.UpdateProgress(count, finalFiles.Count + 1, "Createing files.txt");
            //文件Hash
            string hash = "";
            //取到文件路径
            string _path = file.Replace(m_BundlePutPath + "/", string.Empty);
            FileInfo fi = new FileInfo(file);
            if (Path.GetExtension(file) == ".assetbundle")
            {
                //取到文件在Manifest中引用名字
                string abname = file.Replace(m_BundlePutPath + "/", "");
                //通过引用名字去Manifest文件中获取到该文件的Hash值
                hash = m_Manifest.GetAssetBundleHash(abname).ToString();
            }
            else
            {
                hash = Util.md5file(file);
            }
            totalFileSize += fi.Length;
            //将文件信息按行写入到files文件中 路径|Hash|文件大小(单位B)
            sw.WriteLine(_path + "|" + hash + "|" + fi.Length);
        }
        //最后写入总大小(单位B)
        sw.WriteLine("" + totalFileSize);
        sw.Close();
        fs.Close();
    }
}

using System;
using System.IO;
using System.Text;
#if UNITY_EDITOR
using UnityEditor;
#endif

public class Util {
    /// <summary>
    /// 计算文件的MD5值
    /// </summary>
    public static string md5file(string file)
    {
        try
        {
            FileStream fs = new FileStream(file, FileMode.Open);
            System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
            byte[] retVal = md5.ComputeHash(fs);
            fs.Close();

            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < retVal.Length; i++)
            {
                sb.Append(retVal[i].ToString("x2"));
            }
            return sb.ToString();
        }
        catch (Exception ex)
        {
            throw new Exception("md5file() fail, error:" + ex.Message);
        }
    }

#if UNITY_EDITOR
    public static void BuildSuccessOrFail(string tittle,string message,string okmsg)
    {
        EditorUtility.DisplayDialog(tittle, message, okmsg);
    }

    /// <summary>
    /// Updates the progress.更新进度跳
    /// </summary>
    public static void UpdateProgress(int progress, int progressMax, string desc)
    {
        string title = "Processing...[" + progress + " - " + progressMax + "]";
        float value = (float)progress / (float)progressMax;
        EditorUtility.DisplayProgressBar(title, desc, value);
    }
#endif

}

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

/// <summary>
/// Path utils.路径工具类
/// </summary>
public class PathUtils {

    /// <summary>
    /// 根据一个绝对路径 获得这个资源的assetbundle name
    /// </summary>
    /// <param name="path"></param>
    /// <param name="root">资源文件夹的根目录</param>
    /// <returns></returns>
    public static string GetAssetBundleNameWithPath(string path,string root)
    {
        string str = NormalizePath(path );
        str = ReplaceFirst(str, root + "/", "");
        return str;
    }

    /// <summary>
    /// 获取文件夹的所有文件，包括子文件夹 不包含.meta文件
    /// </summary>
    /// <returns>The files.</returns>
    /// <param name="path">Path.</param>
    public static FileInfo[] GetFiles(string path)
    {
        DirectoryInfo folder = new DirectoryInfo(path);

        DirectoryInfo[] subFolders = folder.GetDirectories();
        List<FileInfo> filesList = new List<FileInfo>();

        foreach (DirectoryInfo subFolder in subFolders)
        {
            filesList.AddRange(GetFiles(subFolder.FullName));
        }

        FileInfo[] files = folder.GetFiles();
        foreach (FileInfo file in files)
        {
            if (file.Extension != ".meta")
            {
                filesList.Add(file);
            }

        }
        return filesList.ToArray();
    }
    /// <summary>
    /// 获取文件夹的所有文件路径，包括子文件夹 不包含.meta文件
    /// </summary>
    /// <param name="path"></param>
    /// <returns></returns>
    public static string[] GetFilesPath(string path)
    {
        DirectoryInfo folder = new DirectoryInfo(path);
        DirectoryInfo[] subFolders = folder.GetDirectories();
        List<string> filesList = new List<string>();

        foreach (DirectoryInfo subFolder in subFolders)
        {
            filesList.AddRange(GetFilesPath(subFolder.FullName));
        }

        FileInfo[] files = folder.GetFiles();
        foreach (FileInfo file in files)
        {
            if (file.Extension != ".meta")
            {
                filesList.Add(NormalizePath(file.FullName));
            }

        }
        return filesList.ToArray();
    }

    /// <summary>
    /// 创建文件目录前的文件夹，保证创建文件的时候不会出现文件夹不存在的情况
    /// </summary>
    /// <param name="path"></param>
    public static void CreateFolderByFilePath(string path)
    {
        FileInfo fi = new FileInfo(path);
        DirectoryInfo dir = fi.Directory;
        if (!dir.Exists)
        {
            dir.Create();
        }
    }

    /// <summary>
    /// 创建文件夹
    /// </summary>
    /// <param name="path"></param>
    public static void CreateFolder(string path)
    {
        DirectoryInfo dir = new DirectoryInfo(path);
        if (!dir.Exists)
        {
            dir.Create();
        }
    }

    /// <summary>
    /// Deletes the file.删除文件
    /// </summary>
    /// <param name="path">Path.</param>
    public static void DeleteFile(string path) 
    {
        if (File.Exists(path)) File.Delete(path);
    }

    /// <summary>
    /// 规范化路径名称 修正路径中的正反斜杠
    /// </summary>
    /// <param name="path"></param>
    /// <returns></returns>
    public static string NormalizePath(string path)
    {
        return path.Replace(@"\", "/");
    }

    /// <summary>
    /// //将绝对路径转成工作空间内的相对路径
    /// </summary>
    /// <param name="fullPath"></param>
    /// <returns></returns>
    public static string GetRelativePath(string fullPath,string root,string insert = "Assets")
    {
        string path = NormalizePath(fullPath);
        path = ReplaceFirst(path, root, insert);
        return path;
    }
    /// <summary>
    /// 将相对路径转成绝对路径
    /// </summary>
    /// <param name="relativePath"></param>
    /// <returns></returns>
    public static string GetAbsolutelyPath(string relativePath,string root)
    {
        string path = NormalizePath(relativePath);
        path = ReplaceFirst(root, "Assets", "") + path;
        return path;
    }

    /// <summary>
    /// 替换掉第一个遇到的指定字符串
    /// </summary>
    /// <param name="str"></param>
    /// <param name="oldValue"></param>
    /// <param name="newValue"></param>
    /// <returns></returns>
    public static string ReplaceFirst(string str, string oldValue, string newValue)
    {
        int i = str.IndexOf(oldValue);
        str = str.Remove(i, oldValue.Length);
        str = str.Insert(i, newValue);
        return str;
    }

    /// <summary>
    /// Copies the folder to.从一个目录将其内容复制到另一目录
    /// </summary>
    /// <param name="directorySource">Directory source.</param>
    /// <param name="directoryTarget">Directory target.</param>
    public static void CopyFolderTo(string directorySource, string directoryTarget)
    {
        //检查是否存在目的目录
        if (!Directory.Exists(directoryTarget))
        {
            Directory.CreateDirectory(directoryTarget);
        }
        //先来复制文件
        DirectoryInfo directoryInfo = new DirectoryInfo(directorySource);
        FileInfo[] files = directoryInfo.GetFiles();
        //复制所有文件
        foreach (FileInfo file in files)
        {
            file.CopyTo(Path.Combine(directoryTarget, file.Name));
        }
        //最后复制目录
        DirectoryInfo[] directoryInfoArray = directoryInfo.GetDirectories();
        foreach (DirectoryInfo dir in directoryInfoArray)
        {
            CopyFolderTo(Path.Combine(directorySource, dir.Name), Path.Combine(directoryTarget, dir.Name));
        }
    }

    /// <summary>
    /// Creates the stream dir.创建路径
    /// </summary>
    /// <returns>The stream dir.</returns>
    /// <param name="dir">Dir.</param>
    public static string CreateStreamDir(string dir)
    {
        string path = Application.streamingAssetsPath + "/" + dir;

        if (!File.Exists(path))
        {
            Directory.CreateDirectory(path);
        }

        return path;
    }


    /// <summary>
    /// Gets all dirs.获取文件路径
    /// </summary>
    /// <param name="dir">Dir.</param>
    /// <param name="list">List.</param>
    public static void GetAllDirs(string dir, List<string> list)
    {
        string[] dirs = Directory.GetDirectories(dir);
        list.AddRange(dirs);

        for (int i = 0; i < dirs.Length; i++)
        {
            GetAllDirs(dirs[i], list);
        }
    }
}