仿LOL项目开发第二天

仿LOL项目开发第二天

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　by草帽

接着上节来讲，上节更新还没开始写代码逻辑，今天我们补充完整。

我们找到VersionManager脚本里面的CheckVersion方法：

首先我们想到检测版本，需要从服务器下载信息，那么肯定要提前检测下网络是否良好，并比较版本信息。

所以，我们写个BeforeCheck方法：

 

    /// <summary>
    /// 检测网络状况并对照版本信息是否一致
    /// </summary>
    /// <param name="AsynResult">版本信息是否一致的处理委托</param>
    /// <param name="OnError">错误处理委托</param>
    public void BeforeCheck(Action<bool> AsynResult, Action OnError)
    {
        CheckTimeout checkTimeout = new CheckTimeout();
        checkTimeout.AsynIsNetworkTimeout((success) => 
        {
            //如果网络良好，开始下载服务器版本xml
            if (success)
            {

            }
            else 
            {
                if (OnError != null)
                {
                    OnError();
                }
            }
        });
    }

 在写网络良好判断的带参匿名委托之前，我们先来思考一个问题，网络良好接下来需要做什么？

就是下载服务端的版本信息，但是得需要一个url地址来访问？

那么这个服务端版本信息的URL在哪里？难道要把绝对的URl定死的写入到代码中。

假如我以后服务器的URL换了呢？那么就要重新改写代码。这种方案否决，不可取。

所以呢，这个服务器的URL应该得写入到配置文件中，从服务器那边下载。

非常nice，之前我们不是写个一个SystemConfig,我们就在里面初始化服务器的URL。

所以SystemConfig需要一个Init()的初始方法。

初始配置文件分为两类：

1.从服务器那边获取的配置信息，比如版本信息，游戏服务器各个大区的信息

2.本地配置信息，比如声音大小，屏幕分辨率等等

首先，先来加载服务器相关的配置信息，与服务器相关的，我们需要分类：所以写个CfgInfo类：

 

    public class CfgInfo
    {
        public int id { get; set; }
        public string name { get; set; }
        public string url { get; set; }
    }

比如版本信息类id=0，游戏服务器大区类id=1，然后分别对应着不同的url，这样我们管理起来就清晰多了。

那么这个CfgInfo信息是哪里来的，肯定也需要访问服务器那边的url获取，所以呢，我们在Resources文件夹下面创建一个txt，里面写着这个Url，然后访问URl，读取里面的内容初始化所有的CfgInfo类存到列表中List<CfgInfo>，最后还要把Url文本保存在持久文件夹下，以便以后使用，OK分析完之后。

在SystemConfig类下创建常量：CfgPath持久路径

 

public readonly static string CfgPath = Application.persistentDataPath + "/cfg.xml";

 

然后我们在SystemConfig里面创建LoadCfgInfo（）方法，在Init（）里面调用：

 

private static bool LoadCfgInfo()
    {
        string cfgStr = null;
        //如果存在持久路径，就直接加载文本
        if (File.Exists(CfgPath))
        {
            cfgStr = UnityTools.LoadFileText(CfgPath);
        }
        else 
        {
            //从Resources从加载配置文本
            TextAsset cfgUrl = Resources.Load("cfg") as TextAsset;
            if (cfgUrl)
            {
                //从网页上下载与服务端有关的所有配置xml字符串
                cfgStr = DownloadMgr.Instance.DownLoadHtml(cfgUrl.text);
            }
            else
            {
                cfgStr = null;
            }
        }
        //加载xml内容为列表类
        CfgInfoList = LoadXMLText<CfgInfo>(cfgStr);
        return true;
    }

 

　

 

LoadXMLText<T>(string xmlText):

 

    /// <summary>
    /// 将xml转换成list<T>列表类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="xmlText"></param>
    /// <returns></returns>
    private static List<T> LoadXMLText<T>(string xmlText)
    {
        List<T> list = new List<T>();
        try
        {
            if (string.IsNullOrEmpty(xmlText))
            {
                return list;
            }
            Type type = typeof(T);
            XmlDocument doc = XmlResAdapter.GetXmlDocument(xmlText);
            Dictionary<int,Dictionary<string,string>> map = XmlResAdapter.LoadXMLToMap(doc,xmlText);
            var props = type.GetProperties(~System.Reflection.BindingFlags.Static);
            foreach (var item in map)
            {
                var obj = type.GetConstructor(Type.EmptyTypes).Invoke(null);
                foreach (var prop in props)
                {
                    if (prop.Name == "id")
                    {
                        prop.SetValue(obj,item.Key,null);
                    }
                    else
                    {
                        try
                        {
                            if (item.Value.ContainsKey(prop.Name))
                            {
                                var value = UnityTools.GetValue(item.Value[prop.Name],prop.PropertyType);
                                prop.SetValue(obj,value,null);
                            }
                        }
                        catch(Exception e)
                        {
                            Debug.LogException(e);
                        }
                    }
                }
                list.Add((T)obj);
            }
        }
        catch(Exception e)
        {
            Debug.LogException(e);
        }
        return list;
    }

 

　　

 

XmlResAdapter.LoadXMLToMap():

 

        /// <summary>
        /// 将xml内容转换成map
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="content"></param>
        /// <returns></returns>
        public static Dictionary<int, Dictionary<string, string>> LoadXMLToMap(XmlDocument doc, string content)
        {
            var result = new Dictionary<int, Dictionary<string, string>>();
            int index = 0;
            foreach (XmlNode item in doc.SelectSingleNode("root").ChildNodes)
            {
                index++;
                if (item.ChildNodes == null || item.ChildNodes.Count == 0)
                {
                    continue;
                }
                int key = int.Parse(item.ChildNodes[0].InnerText);
                if (result.ContainsKey(key))
                {
                    continue;
                }
                var children = new Dictionary<string, string>();
                result.Add(key, children);
                for (int i = 1; i < item.ChildNodes.Count; i++)
                {
                    XmlNode node = item.ChildNodes[i];
                    string tag = null;
                    if (node.Name.Length < 3)
                    {
                        tag = node.Name;
                    }
                    else 
                    {
                        string tagTial = node.Name.Substring(node.Name.Length - 2, 2);
                        if (tagTial == "_i" || tagTial == "_s" || tagTial == "_f" || tagTial == "_l" || tagTial == "_k" || tagTial == "_m")
                        {
                            tag = node.Name.Substring(0, node.Name.Length - 2);
                        }
                        else 
                        {
                            tag = node.Name;
                        }
                    }
                    if (node != null && !children.ContainsKey(tag))
                    {
                        if (string.IsNullOrEmpty(node.InnerText))
                        {
                            children.Add(tag, "");
                        }
                        else
                        {
                            children.Add(tag, node.InnerText.Trim());
                        }
                    }
                }
            }
            return result;
        }

 

　　

 

所以这里我们就需要用到第一节提到的准备工具：WampServer集成的网页开发工具：

因为这里我们需要涉及到访问服务器的url，所以我们自己架设一个http服务器站点。

打开WampServer，找到www目录

然后新建一个文件夹，命名为LOLGameDemo

在这个文件夹下面新建一个xml，命名为Cfg.xml

然后回到Unity的Resources文件下面新建一个txt，也命名为Cfg.txt。

编辑txt里面的内容：

然后编辑Cfg.xml的内容：

然后在LOLGameDemo文件夹下，新创建一个ServerVersion.xml文本，为服务器的版本信息：

OK，大功告成。接着我们回到VersionManager里面的BeforeCheck方法里面：

我们要获取到服务器版本的url，所以得回到SystemConfig编写一个GetCfgInfoByName()方法或者GetCfgInfoById()的接口。

GetCfgInfoByName()：

    /// <summary>
    /// 根据名字取得服务端配置信息Url
    /// </summary>
    /// <param name="name"></param>
    /// <returns></returns>
    public static string GetCfgInfoUrlByName(string name)
    {
        string result = "";
        foreach (var item in CfgInfoList)
        {
            if (item.name == name)
            {
                result = item.url;
                break;
            }
        }
        return result;
    }

 

GetCfgInfoById()：

 

    /// <summary>
    /// 根据id取得服务端配置信息Url
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public static string GetCfgInfoUrlById(int id)
    {
        string result = "";
        foreach (var item in CfgInfoList)
        {
            if (item.id == id)
            {
                result = item.url;
                break;
            }
        }
        return result;
    }

 

因为我们下载的服务器的版本文本也要保存在持久文件目录，所以：

 

public readonly static string ServerVersionPath = Application.persistentDataPath + "/serverVersion.xml";

还有之前我们只是初始化本地版本信息类的实例，所以现在我们在VersionManager创建一个服务端的版本信息类：

 

    /// <summary>
    /// 本地版本信息属性
    /// </summary>
    public VersionManagerInfo LocalVersion { get; private set; }
    /// <summary>
    /// 服务版本信息属性
    /// </summary>
    public VersionManagerInfo ServerVersion { get; private set; }

 

然后再次回到BeforeCheck方法里面，终于回来了！0.0！

 

public void BeforeCheck(Action<bool> AsynResult, Action OnError)
    {
        CheckTimeout checkTimeout = new CheckTimeout();
        checkTimeout.AsynIsNetworkTimeout((success) => 
        {
            //如果网络良好，开始下载服务器版本xml
            if (success)
            {
                DownloadMgr.Instance.AsynDownLoadHtml(SystemConfig.GetCfgInfoUrlByName("version"), 
                (serverVersion) => 
                {
                    //如果本地存在服务端的版本信息文本，覆盖下载的服务器文本
                    if (File.Exists(SystemConfig.ServerVersionPath))
                    {
                        serverVersion = UnityTools.LoadFileText(SystemConfig.ServerVersionPath);
                    }
                    //将文本转换成版本信息类
                    ServerVersion = GetVersionInXml(serverVersion);
　　　　　　　　　　　　//开始进行比较版本号
                    bool programVersion = ServerVersion.ProgramVersionCodeInfo.Compare(LocalVersion.ProgramVersionCodeInfo) > 0;
                    bool resourceVersion = ServerVersion.ResourceVersionCodeInfo.Compare(LocalVersion.ResourceVersionCodeInfo) > 0;
                    //执行是否更新的委托
                    AsynResult(programVersion || resourceVersion);
                },OnError);
            }
            else 
            {
                if (OnError != null)
                {
                    OnError();
                }
            }
        });
    }

 然后回到VersionManager的CheckVersion方法中，将BeforeCheck方法写入到里面。

 

    public void CheckVersion(Action<bool> fileDecompress,Action<int,int,string> taskProgress,Action<int,long,long> progress,Action finished,Action<Exception> error)
    {
        BeforeCheck((result) =>
        {
            if (result)
            {
                //需要更新
                Debug.Log("需要更新");
            }
            else
            {
                //不需要更新
                Debug.Log("不需要更新");
            }
        }, () => { error(new Exception("下载版本文件超时！")); });
    }

 

　　

 

运行程序，发现在打印窗口输出：

不需要更新的字样，如果我们想要需要更新，就需要修改ServerVersion.xml文件：

将Resource资源版本提高一个版本号：这样就比本地LocalVersion高一点。

运行程序，再次看打印窗口：

这次就出现了更新字样。这里我只是打印消息，接下来，我们正式进入开始下载资源包代码编写：

创建一个方法CheckAndDownload()：

在写这个方法之前，先分析一下，下载一个需要更新的资源包，我们怎么知道这个资源包得需要更新，还有我们得验证这个资源包的md5码，所以综上，我们得封装一个资源包类：PackageInfo

 

/// <summary>
/// 资源包
/// </summary>
public class PackageInfo 
{
    /// <summary>
    /// 包名
    /// </summary>
    public string Name;
    /// <summary>
    /// 资源适用最低版本号
    /// </summary>
    public VersionCodeInfo LowVersion;
    /// <summary>
    /// 资源适用最高版本号
    /// </summary>
    public VersionCodeInfo HighVersion;
    /// <summary>
    /// 资源md5码
    /// </summary>
    public string MD5;
}

 然后从之前我们下载的服务器版本信息取得PackageMd5List的url，然后访问这个url，根据内容初始化需要下载Pakcage的信息。

DownloadPackageInfoList：

 

    /// <summary>
    /// 取得下载包的信息
    /// </summary>
    /// <param name="AsynResult"></param>
    /// <param name="OnError"></param>
    private void DownloadPackageInfoList(Action<List<PackageInfo>> AsynResult, Action OnError)
    {
        //从服务器版本信息中取得下载Url，然后初始化下载包的信息
        DownloadMgr.Instance.AsynDownLoadHtml(ServerVersion.PackageMd5List, 
        (content) => 
        {
            XmlDocument doc = XmlResAdapter.GetXmlDocument(content);
            if (null == doc)
            {
                if (OnError != null)
                {
                    OnError();
                }
            }
            else 
            {
                List<PackageInfo> packagesList = new List<PackageInfo>();
                foreach (XmlNode node in doc.SelectSingleNode("root").ChildNodes)
                {
                    PackageInfo package = new PackageInfo();
                    string packagetName = node.Attributes["name"].Value;
                    package.Name = packagetName;
                    //从第7个开始，也就是说前7个是资源包文件名，后4位是包后缀名.zip
                    string version = packagetName.Substring(7, packagetName.Length - 11);
                    //中间是低版本和高版本===>比如0.0.0.0-0.0.0.3
                    string firstVersion = version.Substring(0,version.IndexOf("-"));
                    package.LowVersion = new VersionCodeInfo(firstVersion);
                    string endVersion = version.Substring(version.Length + 1);
                    package.HighVersion = new VersionCodeInfo(endVersion);
                    //然后内容是md5码
                    package.MD5 = node.InnerText;
                    packagesList.Add(package);
                    ServerVersion.PackageMd5Dic.Add(package.Name, package.MD5);
                }
                AsynResult(packagesList);
            }
        }, OnError);
    }

 

　　

 

然后提供给上层的委托的参数是List<PackageInfo>,上层在取得所有的包，然后判断哪些包是需要下载的，然后进行下载。

AsynDownloadUpdatePackage：

 

private void AsynDownloadUpdatePackage(Action<bool> fileDecompress, Action<int, int, string> taskProgress, Action<int, long, long> progress, Action finished, Action<Exception> error)
    {
        DownloadPackageInfoList((packageList) =>
        {
            //如果资源包最低版本比游戏的版本高，资源包的最高要求版本比游戏低则需要更新
            var downloadList = (from packageInfo in packageList
                                where packageInfo.LowVersion.Compare(LocalVersion.ResourceVersionCodeInfo) >= 0 && packageInfo.HighVersion.Compare(ServerVersion.ResourceVersionCodeInfo) <= 0
                                select new KeyValuePair<string, string>(packageInfo.HighVersion.ToString(), packageInfo.Name)).ToList();
            string packageUrl = ServerVersion.PackageUrl;
            if (downloadList.Count != 0)
            {
                Debug.Log("开始下载资源包列表");
            }
            else 
            {
                Debug.Log("更新资源包数目为0");
                if (finished != null)
                {
                    finished();
                }
            }
        }, () => { error(new Exception("下载资源包信息出错")); });
    }

CheckAndDownload：

 

public bool CheckAndDownload(Action<bool> fileDecompress, Action<int, int,string> taskProgress, Action<int, long, long> progress, Action finished, Action<Exception> error)
    {
        //资源需要更新，还有就是程序需要更新我不写了，基本上用不到
        if (ServerVersion.ResourceVersionCodeInfo.Compare(LocalVersion.ResourceVersionCodeInfo) > 0)
        {
            //开始下载资源包
            AsynDownloadUpdatePackage(fileDecompress, taskProgress, progress, finished, error);
            return true;
        }
        if (finished != null)
        {
            finished();
        }
        return false;
    }　

 回到CheckVersion方法：

在需要更新的地方调用：CheckDownload（）

 

public void CheckVersion(Action<bool> fileDecompress,Action<int,int,string> taskProgress,Action<int,long,long> progress,Action finished,Action<Exception> error)
    {
        BeforeCheck((result) =>
        {
            if (result)
            {
                //需要更新
                Debug.Log("需要更新");
                CheckAndDownload(fileDecompress, taskProgress, progress, finished, error);
            }
            else
            {
                //不需要更新
                Debug.Log("不需要更新");
            }
        }, () => { error(new Exception("下载版本文件超时！")); });
    }

然后回到ServerVersion.xml修改PackageMd5List标签：

然后去www目录下的LOLGameDemo文件夹下创建PackageMd5List.xml文件：

OK，点击运行程序，观察打印窗口：

程序运行是我们所期望的那样。OK，接着我们就开始写如何下载资源包列表。

 首先呢下载一个资源包就相当于一个下载任务，你看迅雷的下载，你每下载一个资源的时候，他都是封装成一个任务来管理，所以呢，这里我们也新建一个任务类来管理：DownloadTask.cs:

 

using UnityEngine;
using System.Collections;
using System;
/// <summary>
/// 下载任务类
/// </summary>
public class DownloadTask
{
    public string Url { get; set; }
    public string FileName { get; set; }
    public Action<int, long, long> TotalProgress { get; set; }
    public Action<int> Progress { get; set; }
    public Action<long> TotalBytesToReceive { get; set; }
    public Action<long> BytesReceived { get; set; }
    public String MD5 { get; set; }
    public Action Finished { get; set; }
    public Action<Exception> Error { get; set; }
    public bool bFineshed = false;//文件是否下载完成
    public bool bDownloadAgain = false;//是否需要从新下载，如果下载出错的时候会从新下
    public void OnTotalBytesToReceive(long size)
    {
        if (TotalBytesToReceive != null)
            TotalBytesToReceive(size);
    }
    public void OnBytesReceived(long size)
    {
        if (BytesReceived != null)
            BytesReceived(size);
    }
    public void OnTotalProgress(int p, long totalSize, long receivedSize)
    {
        if (TotalProgress != null)
            TotalProgress(p, totalSize, receivedSize);
    }
    public void OnProgress(int p)
    {
        if (Progress != null)
            Progress(p);
    }
    public void OnFinished()
    {
        if (Finished != null)
            Finished();
    }
    public void OnError(Exception ex)
    {
        if (Error != null)
            Error(ex);
    }
}

OK,我们在VersionManager新建一个方法：DownloadPackageList（）下载资源包列表的方法，然后在AsynDownloadUpdatePackage方法的开始下载资源包委托里面调用。

 

private void DownloadPackageList(Action<bool> fileDecompress, string packageUrl, List<KeyValuePair<String, String>> downloadList, Action<int, int, string> taskProgress, Action<int, long, long> progress, Action finished, Action<Exception> error)
    {
        //下载列表
        List<DownloadTask> allTasks = new List<DownloadTask>();
        for (int i = 0; i < downloadList.Count; i++)
        {
            KeyValuePair<string, string> kvp = downloadList[i];
            string localFile = string.Concat(SystemConfig.ResourceFolder, kvp.Value);//dataPath+"/Resources/"+文件名
            //下载完成之后回调委托
            Action OnDownloadFinished =()=>
            {
                //进行解压，以后再来
            };
            string fileUrl = string.Concat(packageUrl, kvp.Value);//"http://127.0.0.1/LOLGameDemo/LOLPackage/"+文件名
            //初始化任务
            var task = new DownloadTask
            {
                FileName = localFile,//dataPath+"/Resources/"+文件名
                Url = fileUrl,//下载url
                Finished = OnDownloadFinished,//解压更新版本信息
                Error = error,
                TotalProgress = progress
            };
            string fileNameNoExtension = kvp.Value;
            if (ServerVersion.PackageMd5Dic.ContainsKey(fileNameNoExtension))
            {
                task.MD5 = ServerVersion.PackageMd5Dic[fileNameNoExtension];
                allTasks.Add(task);
            }
            else 
            {
                error(new Exception("下载包不存在：" + fileNameNoExtension));
                return;
            }
        }
        //全部任务下载完成回调
        Action AllFinished = () => 
        {
            Debug.Log("全部下载完成");
            finished();
        };
        //添加taskProgress的回调
        Action<int, int, string> TaskProgress = (total, current, filename) =>
        {
            if (taskProgress != null)
                taskProgress(total, current, filename);
        };
        //添加文件解压的回调函数
        Action<bool> filedecompress = (decompress) =>
        {
            if (fileDecompress != null)
                fileDecompress(decompress);
        };
        DownloadMgr.Instance.Tasks = allTasks;
        DownloadMgr.Instance.AllDownloadFinished = AllFinished;
        DownloadMgr.Instance.TaskProgress = TaskProgress;
        DownloadMgr.Instance.FileDecompress = filedecompress;
        DownloadMgr.Instance.CheckDownloadList();
    }

看到了委托的好处了吧，LOLGameDriver里面的委托直接传递到Download里面去执行，真正做到解耦和。符合迪米特法则，不是朋友的类，坚决不要持有他的依赖。

Ok，我们在下载之前先要检测下任务列表，因为可能我们是断点下载，比如说有些文件我们已经下载完成了，放在磁盘上，但是第二天起来又继续更新下载，那么已经下载的这些任务我们得检测下，看是否已经下载过了。

所以在DownloadMgr创建一个CheckDownloadList()方法：

 

    /// <summary>
    /// 检测下载列表
    /// </summary>
    public void CheckDownloadList()
    {
        if (Tasks.Count == 0)
        {
            //下载列表为空
            return;
        }
        //已经下载完成的数目
        int finishedCount = 0;
        foreach (var task in Tasks)
        {
            if (task.bFineshed && !task.bDownloadAgain)
            {
                finishedCount++;
            }
            else 
            {
                //是否文件存放的目录已经存在，如果不存在就创建
                string dir = Path.GetDirectoryName(task.FileName);
                if (!string.IsNullOrEmpty(dir) && !Directory.Exists(task.FileName))
                {
                    Directory.CreateDirectory(dir);
                }
                //开始断点下载
            }
            break;
        }
        //说明全部任务下载完成
        if (finishedCount > m_listTasks.Count - 1)
        {
            m_listTasks.Clear();
            m_listTasks = null;
            if (AllDownloadFinished != null)
            {
                AllDownloadFinished();
                AllDownloadFinished = null;
            }
        }
    }

OK，我们开始写断点下载的代码：

之前我们讲过一个类要具有单一职责，但是发现单例模式好像违背了单一职责，单例的好像什么事情都干，就拿这个DownloadMgr来说，我们知道，下载分为两种：

1.断点下载（可继续）

2.非断点下载（重新下载）

那么，因为都是下载，所以我们得吧代码全部写到DownloadMrg里面去，那么这样的职责就分的不清不楚。那么怎么避免呢？

所以我们可以重新封装一个职责类，比如断点下载：ThreadDownloadBreakPoint.cs

 

using UnityEngine;
using System.Collections;
/// <summary>
/// 断点下载类
/// </summary>
public class ThreadDownloadBreakPoint
{
    public DownloadMgr Mgr { get; set; }
    public DownloadTask Task { get; set; }
    public ThreadDownloadBreakPoint()
    {
 
    }
    public ThreadDownloadBreakPoint(DownloadMgr mgr, DownloadTask task)
    {
        Mgr = mgr;
        Task = task;
    }
    public void Download()
    {
        Mgr.DownloadFileBreakPoint(Task.Url, Task.FileName);
    }
}

 实则就是将DownloadMgr重新封装一层，但这个非常有用，因为职责变的清晰，我们完全可以不理会DownloadMrg里面是怎么实现断点下载的，我们只知道ThreadDownloadBreakPoint有提供断点下载的方法接口。

因为这个项目是我一个人开发的，所以我们必须得知道底层的实现。

回到DownloadMrg新建一个方法：DownloadFileBreakPoint

 

    /// <summary>
    /// 断点下载文件
    /// </summary>
    /// <param name="url">网站资源url</param>
    /// <param name="filePath">保存文件路径</param>
    public void DownloadFileBreakPoint(string url, string filePath)
    {
        try
        {
            var requestUrl = new Uri(url);
            var request = (HttpWebRequest)WebRequest.Create(requestUrl);
            var response = (HttpWebResponse)request.GetResponse();
            long contentLength = response.ContentLength;
            response.Close();
            request.Abort();
            long leftSize = contentLength;
            long position = 0;
            if (File.Exists(filePath))
            {
                Debug.Log("需要下载的文件已经存在");
                using (FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate,FileAccess.ReadWrite, FileShare.ReadWrite))
                {
                    leftSize = contentLength - fs.Length;
                    position = fs.Length;
                }
            }
            var partRequest = (HttpWebRequest)WebRequest.Create(requestUrl);
            if (leftSize > 0)
            {
                partRequest.AddRange((int)position, (int)(position + leftSize));
                var partResponse = (HttpWebResponse)partRequest.GetResponse();
                ReadBytesFromResponseToFile(url, partResponse, position, leftSize, contentLength, filePath);
                partResponse.Close();
            }
            partRequest.Abort();
            //下载完成
            Finished(url);
        }
        catch (Exception e)
        {
            Finished(url, e);
        }
    }

ReadBytesFromResponseToFile：

 

   /// <summary>
    /// 从网上下载资源字节到存到文件中
    /// </summary>
    /// <param name="requestUrl"></param>
    /// <param name="response"></param>
    /// <param name="allFilePointer"></param>
    /// <param name="length"></param>
    /// <param name="totalSize"></param>
    /// <param name="filePath"></param>
    private void ReadBytesFromResponseToFile(string requestUrl,WebResponse response,long allFilePointer,long length,long totalSize,string filePath)
    {
        try
        {
            int bufferLength = (int)length;
            byte[] buffer = new byte[bufferLength];
            //本块位置指针
            int currentChunkPointer = 0;
            //指针偏移量
            int offset = 0;
            using (Stream resStream = response.GetResponseStream())
            {
                //下载的字节数
                int receivedBytesCount;
                do
                {
                    receivedBytesCount = resStream.Read(buffer, offset, bufferLength - offset);
                    offset += receivedBytesCount;
                    if (receivedBytesCount > 0)
                    {
                        byte[] bufferCopyed = new byte[receivedBytesCount];
                        Buffer.BlockCopy(buffer, currentChunkPointer, bufferCopyed, 0, bufferCopyed.Length);
                        using (FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite))
                        {
                            fs.Position = allFilePointer;
                            fs.Write(bufferCopyed,0,bufferCopyed.Length);
                            fs.Close();
                        }
                        float progress = (allFilePointer + bufferCopyed.Length) / totalSize;
                        //执行进度委托
                        Action action = () => 
                        {
                            if (m_listTasks.Any(task => task.Url == requestUrl))
                            {
                                DownloadTask task = this.m_listTasks.FirstOrDefault(t => t.Url == requestUrl);
                                task.TotalProgress((int)(progress*100), 0, 0);
                                if (TaskProgress != null)
                                {
                                    int finishedCount = this.m_listTasks.Count(t => t.bFineshed);
                                    string filename = task.FileName.Substring(task.FileName.LastIndexOf("/") + 1);
                                    TaskProgress(m_listTasks.Count, finishedCount, filename);
                                }
                            }
                        };
                        action.Invoke();
                        currentChunkPointer += receivedBytesCount;
                        allFilePointer += receivedBytesCount;
                    }
                } while (receivedBytesCount != 0);
            }
        }
        catch (Exception e)
        {
            Debug.LogException(e);
        }
    }

Finished：

 

    private void Finished(string url, Exception e = null)
    {
        Debug.Log("下载完成！");
        DownloadTask task = this.m_listTasks.FirstOrDefault(t => t.Url == url);
        if (task != null)
        {
            if (e != null)
            {
                Debug.LogWarning("下载出错！" + e.Message);
            }
            else 
            {
                //验证MD5码
                DownloadFinishedWithMd5(task);
            }
        }
    }

 

最后进行Md5的验证，成功就修改任务finished布尔为true。

 

    /// <summary>
    /// 下载完成之后验证MD5码
    /// </summary>
    /// <param name="task"></param>
    private void DownloadFinishedWithMd5(DownloadTask task)
    {
        string md5 = UnityTools.BuildFileMd5(task.FileName);
        if ("123".Trim() != task.MD5.Trim())
        {
            //MD5验证失败
            if (File.Exists(task.FileName))
            {
                File.Delete(task.FileName);
            }
            task.bDownloadAgain = true;
            task.bFineshed = false;
            CheckDownloadList();
            return;
        }
        if (FileDecompress != null)
        {
            FileDecompress(true);
        }
        task.bDownloadAgain = false;
        task.bFineshed = true;
        task.Finished();
        if (FileDecompress != null)
        {
            FileDecompress(false);
        }
        CheckDownloadList();
    }

因为我做下测试，所以我这里只是用“123”来代替md5，实际上的话，得自己取得下载后文件的MD5码和服务器上的MD5验证，如果通过的话，就完成，没通过的话重新下载。

UnityTools.BuildFileMd5:

 

        /// <summary>
        /// 生成文件的md5码
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public static string BuildFileMd5(string filePath)
        {
            string fileMd5 = null;
            try
            {
                using (FileStream fs = File.OpenRead(filePath))
                {
                    MD5 md5 = MD5.Create();
                    byte[] fileMd5bytes = md5.ComputeHash(fs);
                    fileMd5 = System.BitConverter.ToString(fileMd5bytes).Replace("_", "").ToLower();
                }
            }
            catch (Exception e)
            {
                Debug.Log(e);
            }
            return fileMd5;
        }

 

　　

 

最后回到DownloadMgr里面的CheckDownloadList方法里面，在开始断点下载处，添加代码：

 

    /// <summary>
    /// 检测下载列表
    /// </summary>
    public void CheckDownloadList()
    {
        if (Tasks.Count == 0)
        {
            //下载列表为空
            return;
        }
        //已经下载完成的数目
        int finishedCount = 0;
        foreach (var task in Tasks)
        {
            if (task.bFineshed && !task.bDownloadAgain)
            {
                finishedCount++;
            }
            else 
            {
                //是否文件存放的目录已经存在，如果不存在就创建
                string dir = Path.GetDirectoryName(task.FileName);
                if (!string.IsNullOrEmpty(dir) && !Directory.Exists(task.FileName))
                {
                    Directory.CreateDirectory(dir);
                }
                //开始断点下载
                ThreadDownloadBreakPoint bpDownload = new ThreadDownloadBreakPoint(this, task);
                Thread t = new Thread(bpDownload.Download);
                t.Start();
            }
            break;
        }
        if (finishedCount > m_listTasks.Count - 1)
        {
            m_listTasks.Clear();
            m_listTasks = null;
            if (AllDownloadFinished != null)
            {
                AllDownloadFinished();
                AllDownloadFinished = null;
            }
        }
    }

开启一个线程来断点下载。

OK，欧了。我们来做下测试。

到www目录下的LOLGameDemo文件夹下新建一个文件夹：LOLPackage，跟我们的ServerVersion.xml里面的PackageUrl的文件目录一致：

这个文件主要是来存放需要更新的资源文件包。然后在里面新建一个压缩包，和我们的PackageMd5List的name属性一致：

然后就启动程序，观察unity:

可以看到在Project的Resources文件夹下，多了一个压缩包：就是我们放在Http服务器的压缩包，说明下载成功了。

 

仿LOL项目开发第三天链接地址

 

转载于:https://www.cnblogs.com/CaomaoUnity3d/p/5459265.html