热更Manager

在网络游戏的入口，每次启动时都需要检测服务器是否有更新。

我们每次打AB包时，都会在Resource文件夹内生成ABMD5.bytes文件，记录最新的assetbundle文件的md5信息。这个ABMD5 .bytes文件还会根据版本和平台拷贝到工程文件夹下的Version文件夹内。

我们打热更包时，就需要指定版本的ABMD5 .bytes文件，从而将筛选打出的热更包放进工程文件夹下的Hot文件夹内。注意每次打热更包时，我们都会先打一次AB包，但是Resource文件夹内的ABMD5.bytes文件和Version文件夹内的ABMD5不会更新，它们只有正常打AB包和发布标准包时才会更新。这也意味着我们打出来的热更包都是基于当前版本的，客户端只需要下载最新的热更包即可。

当我们发布标准包时，我们在Resources文件夹内还会添加一个Version.txt文件。这个文件就是客户端的版本信息，客户端通过这个文件来读取自己的版本信息来和服务器进行比对。

HotPatchManager

我们在ResFrame——Frames——ResourceFrm——Download文件夹下新建HotPatchManager

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

public class HotPatchManager : SingletonPattern<HotPatchManager>
{
    /// <summary>
    /// 需要下载的资源总个数
    /// </summary>
    public int LoadFileCount { get; set; } = 0;
    /// <summary>
    /// 需要下载资源的总大小（kb）
    /// </summary>
    public float LoadSumSize { get; set; } = 0;


    private MonoBehaviour m_Mono;
    private string m_DownLoadPath = Application.persistentDataPath + "/DownLoad";
    private string m_CurVersion;//从Version.txt中读出来的版本信息。
    public string m_CurPackName;

    private string m_ServerInfoPath = Application.persistentDataPath + "/ServerInfo.xml";
    private string m_LocalInfoPath = Application.persistentDataPath + "/LocalInfo.xml";
    private ServerInfo m_ServerInfo;
    private ServerInfo m_LocalInfo;
    private VersionInfo m_GameVersion;//从ServerInfo中读出来的VersionInfo信息
    public string CurVersion => m_CurVersion;
    /// <summary>
    /// 当前热更Patches
    /// </summary>
    private Patches m_CurrentPatches;
	/// <summary>
    /// 当前热更Patches
    /// </summary>
    public Patches CurrentPatches => m_CurrentPatches;
    /// <summary>
    /// 所有热更包信息的字典
    /// </summary>
    private Dictionary<string,Patch> m_HotFixDic = new Dictionary<string,Patch>();
    /// <summary>
    /// 所有需要下载的Patch列表
    /// </summary>
    private List<Patch> m_DownloadList = new List<Patch>();
    /// <summary>
    /// 所有需要下载的Patch的字典
    /// </summary>
    private Dictionary<string,Patch> m_DownloadDic = new Dictionary<string,Patch>();
    /// <summary>
    /// 服务器列表获取错误回调
    /// </summary>
    public event Action ServerInfoError;
    
    public void Init(MonoBehaviour mono)
    {
        m_Mono = mono;
    }
    /// <summary>
    /// 检测版本是否热更
    /// </summary>
    public void CheckVersion(Action<bool> hotCallback = null)
    {
        m_HotFixDic.Clear();
        ReadVersion();
        m_Mono.StartCoroutine(GetServerInfo(() =>
        {
            if(m_ServerInfo == null)
            {
                if(ServerInfoError != null)
                {
                    ServerInfoError.Invoke();
                }
                return;
            }

            foreach (VersionInfo versionInfo in m_ServerInfo.GameVersion)
            {
                if (versionInfo.Version == m_CurVersion)
                {
                    m_GameVersion = versionInfo;
                    break;
                }
            }
            GetHotAB();

            if (CheckLocalAndServerPatch())
            {
                ComputeDownload();
                if(File.Exists(m_ServerInfoPath))
                {
                    if(File.Exists(m_LocalInfoPath))
                    {
                        File.Delete(m_LocalInfoPath);
                    }
                    File.Move(m_ServerInfoPath, m_LocalInfoPath);//相当于重命名
                }
            }
            else
            {
                CheckLocalResource();
            }
            LoadFileCount = m_DownloadList.Count;
            LoadSumSize = m_DownloadList.Sum(x => x.Size);

            hotCallback?.Invoke(m_DownloadList.Count > 0);
        }));
    }
    /// <summary>
    /// 检查本地资源是否与服务器下载列表信息一致，用于下载中断后重新开始
    /// </summary>
    void CheckLocalResource()
    {
        m_DownloadList.Clear();
        m_DownloadDic.Clear();
        if (m_GameVersion != null && m_GameVersion.Patches != null && m_GameVersion.Patches.Length > 0)
        {
            m_CurrentPatches = m_GameVersion.Patches[m_GameVersion.Patches.Length - 1];
            if (m_CurrentPatches.Files != null && m_CurrentPatches.Files.Count > 0)
            {
                foreach (Patch patch in m_CurrentPatches.Files)
                {
                    if ((Application.platform == RuntimePlatform.WindowsPlayer ||
                        Application.platform == RuntimePlatform.WindowsEditor) &&
                        patch.Platform.Contains("StandaloneWindows64"))
                    {
                        AddDownloadList(patch);
                    }
                    else if ((Application.platform == RuntimePlatform.Android ||
                        Application.platform == RuntimePlatform.WindowsEditor) &&
                        patch.Platform.Contains("Android"))
                    {
                        AddDownloadList(patch);
                    }
                    else if ((Application.platform == RuntimePlatform.IPhonePlayer ||
                        Application.platform == RuntimePlatform.WindowsEditor) &&
                        patch.Platform.Contains("IOS"))
                    {
                        AddDownloadList(patch);
                    }
                }
            }
        }
    }
    /// <summary>
    /// 检查客户端缓存的ServerInfo和服务器的ServerInfo来确定是否需要热更
    /// </summary>
    /// <returns>是否热更</returns>
    bool CheckLocalAndServerPatch()
    {
        if (!File.Exists(m_LocalInfoPath))
        {
            return true;
        }
        m_LocalInfo = BinarySerializeOpt.XmlDeserialize<ServerInfo>(m_LocalInfoPath);
        VersionInfo localGameVersion = null;
        if(m_LocalInfo != null)
        {
            foreach (VersionInfo versionInfo in m_LocalInfo.GameVersion)
            {
                if (versionInfo.Version == m_CurVersion)
                {
                    localGameVersion = versionInfo;
                    break;
                }
            }
        }
        if(localGameVersion != null &&
            m_GameVersion.Patches != null &&
            localGameVersion.Patches != null &&
            m_GameVersion.Patches.Length >0 &&
            m_GameVersion.Patches[m_GameVersion.Patches.Length - 1].Version != localGameVersion.Patches[localGameVersion.Patches.Length - 1].Version)
        {
            return true;
        }

        return false;
    }
    /// <summary>
    /// 读取打包时的版本
    /// </summary>
    void ReadVersion()
    {
        TextAsset versionTex = Resources.Load<TextAsset>("Version");
        if(versionTex == null)
        {
            Debug.LogError("未读到本地版本！");
            return;
        }
        string[] all = versionTex.text.Split('\n'); 
        if(all.Length > 0)
        {
            string[] infoList = all[0].Split(';');
            if(infoList.Length >= 2)
            {
                m_CurVersion = infoList[0].Split('|')[1];
                m_CurPackName = infoList[1].Split('|')[1];
            }
        }
    }

    IEnumerator GetServerInfo(Action callBack)
    {
        string infoURL = "http://127.0.0.1/ServerInfo.xml";
        UnityWebRequest request = UnityWebRequest.Get(infoURL);
        request.timeout = 30;//超过30秒没有结果就报错
        yield return request.SendWebRequest();

        if(request.result == UnityWebRequest.Result.ConnectionError || 
            request.result == UnityWebRequest.Result.ProtocolError ||
            request.result == UnityWebRequest.Result.DataProcessingError)
        {
            Debug.Log("Download Error：" + request.error);
            request.Dispose();
        }
        else
        {
            //在Unity downloadHandler中，下载的文件是按照二进制流的形式下载。
            //所以我们也要按照二进制写入。注意最后的文件类型和服务器保持一致，
            //虽然传输的形式是二进制流，但写入后该是Xml还是Xml，该是Json还是Json
            FileTool.CreateFile(m_ServerInfoPath, request.downloadHandler.data);
            if(File.Exists(m_ServerInfoPath))
            {
                m_ServerInfo = BinarySerializeOpt.XmlDeserialize<ServerInfo>(m_ServerInfoPath);
            }
            else
            {
                Debug.LogError("热更配置读取错误！");
            }
            request.Dispose();
        }

        callBack?.Invoke();
    }
    /// <summary>
    /// 获取当前版本的热更包信息,用于和服务器确认AB包，防止客户端非法读取AB包
    /// </summary>
    void GetHotAB()
    {
        if(m_GameVersion != null && m_GameVersion.Patches != null && m_GameVersion.Patches.Length > 0)//防止ServerInfo配置表配错
        {
            //只获取最新的包，因为打热更包时只使用Version信息来比较，打热更包的次数并没有考虑在内。
            Patches lastPatches = m_GameVersion.Patches[m_GameVersion.Patches.Length - 1];
            if(lastPatches != null && lastPatches.Files != null)
            {
                foreach(Patch patch in lastPatches.Files)
                {
                    m_HotFixDic.Add(patch.Name, patch);
                }
            }
        }
    }
    /// <summary>
    /// 计算下载的资源
    /// </summary>
    void ComputeDownload()
    {
        m_DownloadList.Clear();
        m_DownloadDic.Clear();
        if (m_GameVersion != null && m_GameVersion.Patches != null && m_GameVersion.Patches.Length > 0)
        {
            m_CurrentPatches = m_GameVersion.Patches[m_GameVersion.Patches.Length - 1];
            if(m_CurrentPatches.Files != null && m_CurrentPatches.Files.Count > 0)
            {
                foreach (Patch patch in m_CurrentPatches.Files)
                {
                    if ((Application.platform == RuntimePlatform.WindowsPlayer ||
                        Application.platform == RuntimePlatform.WindowsEditor) &&
                        patch.Platform.Contains("StandaloneWindows64"))
                    {
                        AddDownloadList(patch);
                    }
                    else if((Application.platform == RuntimePlatform.Android ||
                        Application.platform == RuntimePlatform.WindowsEditor) &&
                        patch.Platform.Contains("Android"))
                    {
                        AddDownloadList(patch);
                    }
                    else if ((Application.platform == RuntimePlatform.IPhonePlayer ||
                        Application.platform == RuntimePlatform.WindowsEditor) &&
                        patch.Platform.Contains("IOS"))
                    {
                        AddDownloadList(patch);
                    }
                }
            }
        }
    }
    void AddDownloadList(Patch patch)
    {
        string filePath = m_DownLoadPath + "/" + patch.Name;
        //如果客户端本地已经下载了此patch，先通过MD5码校验看看服务端是否更新了此patch
        //如果客户端本地没有下载此patch，先下载此patch
        if (File.Exists(filePath))
        {
            string md5 = MD5Manager.Instance.BuildFileMD5(filePath);
            if (patch.MD5 != md5)
            {
                m_DownloadList.Add(patch);
                m_DownloadDic.Add(patch.Name, patch);
            }
        }
        else
        {
            m_DownloadList.Add(patch);
            m_DownloadDic.Add(patch.Name, patch);
        }
    }
}
public class FileTool
    {
        /// <summary>
        /// 根据二进制流创建文件
        /// </summary>
        /// <param name="filePath">文件创建路径</param>
        /// <param name="bytes">文件二进制流</param>
        public static void CreateFile(string filePath, byte[] bytes)
        {
            if (File.Exists(filePath))
            {
                File.Delete(filePath);
            }
            FileInfo fileInfo = new FileInfo(filePath);
            FileStream fs = fileInfo.Create();
            fs.Write(bytes, 0, bytes.Length);
            fs.Close();
            fs.Dispose();
        }
    }

CheckVersion是主要的入口代码，我们从这里理清楚热更流程

1. ReadVersion：客户端读取在本地Resource文件夹内保存的Version版本。
2. 开启GetServerInfo协程：从服务器获取ServerInfo，这是确认热更的重要文件。
3. 在GetServerInfo的回调内：
   1. 先根据客户端当前版本获取到此版本的VersionInfo
   2. GetHotAB方法：获取当前版本的热更包信息，不管是否需要下载热更包都要获取此信息。用来进一步检验客户端是否正确加载了热更包。因为客户端可能非法加载已经不需要的热更包。
   3. CheckLocalAndServerPatch方法，检查客户端缓存的ServerInfo和服务器的ServerInfo来确定是否需要热更
   4. ComputeDownload，检验客户端本地的已有的包和服务器提供的Info，生成下载列表
   5. CheckLocalResource，检查本地资源是否与服务器下载列表信息是否一致，用于下载中断后重新开始，因为如果下载中途客户端断开，客户端本地缓存的ServerInfo是最新的，不进行二次检查的话热更就无法再下载了。

修正

将BinarySerializeOpt脚本从ConfigFrm移到ResourcFrm文件夹内，因为我们的ResourcFrm文件夹内放有“Resource”程序集定义，而HotPatchManager也在此程序集内，如果BinarySerializeOpt脚本在ConfigFrm文件夹会导致无法引用。

将Script——Manager文件夹内的MD5Manager移动到ResFrame——Frames——ResourceFrm文件夹内

在GameStart里初始化

protected override void Awake()
{
    base.Awake();
    //...
    ObjectPoolManager.Instance.Init(recyclePoolTrans,sceneTrans);
    HotPatchManager.Instance.Init(this);//+++
}