Project_SG_scripts.git

 
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEngine;
using UnityEngine.Networking;
using Cysharp.Threading.Tasks;
 
 
public class DownloadHotMgr : SingletonMonobehaviour<DownloadHotMgr>
{
    #region 配置
    public static int MaxRetryTimes = 5;//最大重试的次数
    public static int MaxDownLoadTask = 15;//最大同时下载数量
    public static int TimeOut = 10;//下载超时时间
    #endregion
 
    #region 任务列表
    private Dictionary<string, DownloadHotTask> allTask = new Dictionary<string, DownloadHotTask>();    //所有任务组
    private Queue<DownloadHotTask> waitTask = new Queue<DownloadHotTask>();    //当前等待下载的任务
    private Dictionary<string, DownloadHotTask> downloadTask = new Dictionary<string, DownloadHotTask>();    //当前正在下载的任务
    #endregion 任务列表
 
    private bool isBegin;
    private int startTickcount = 0;
    private Func<bool, DownloadHotTask, bool> onTaskCompleted;//文件下载完成回调，<是否全部完成，任务对象，return true:立即重试，false:到队尾重试>
 
    //总速度
    private float speed;
    public float Speed { get { UpdateValue(); return speed; } }
    public string SpeedFormat { get { return StringUtility.FormatSpeed(Speed); } }
 
    //总已下载大小
    private long finishedBytes;//已完成任务的大小
    private long downloadedBytes;
    private long downloadedBytesRef;
    public long DownloadedBytes { get { UpdateValue(); return downloadedBytes; } }
 
    public bool IsBegin { get { return isBegin; } }
    public bool IsFinished { get { return allTask.Count == 0; } }
 
    //更新数值
    public void UpdateValue()
    {
        if (startTickcount == 0)//任务还未开始
            return;
        float second = Mathf.Abs(TimeUtility.AllSeconds - startTickcount);
        Debug.LogFormat("更新数值:{0}  {1}  {2}", TimeUtility.AllSeconds, startTickcount, second);
        if (second < 1f)//刷新间隔1秒
            return;
        long bytes = 0;
        long length = 0;
        foreach (var pair in downloadTask)
        {
            var task = pair.Value;
            bytes += task.downloadedBytes;
            length += task.remoteLength;
        }
        downloadedBytes = finishedBytes + bytes;
        // totalLength = length;
 
        var delta = downloadedBytes < downloadedBytesRef || downloadedBytesRef == 0 ? 0 : downloadedBytes - downloadedBytesRef;
        downloadedBytesRef = downloadedBytes;
        speed = delta / second;
        startTickcount = TimeUtility.AllSeconds;
    }
 
    //添加任务
    public DownloadHotMgr AddTask(DownloadHotTask task)
    {
        if (allTask.ContainsKey(task.Key))
        {
            Debug.LogFormat("DownloadMgr-已存在相同的下载任务：{0}", task.Key);
            return this;
        }
        allTask.Add(task.Key, task);
        waitTask.Enqueue(task);
        return this;
    }
 
    //准备下载，重置状态
    public DownloadHotMgr Prepare()
    {
        Stop();
        this.onTaskCompleted = null;
        //清除所有任务
        allTask.Clear();
        waitTask.Clear();
        downloadTask.Clear();
        finishedBytes = 0;
        return this;
    }
 
    /// <summary>
    /// 开始下载
    /// </summary>
    /// <param name="onTaskCompleted">任务结束回调</param>
    /// <returns></returns>
    public DownloadHotMgr Begin(Func<bool, DownloadHotTask, bool> onTaskCompleted = null)
    {
        this.onTaskCompleted = onTaskCompleted;
        startTickcount = TimeUtility.AllSeconds;
        downloadedBytesRef = 0;
        isBegin = true;
        foreach (var pair in downloadTask)
        {
            //重新开始下载任务
            if (pair.Value.BeginDownload(OnTaskCompleted))
                Debug.LogFormat("重新开始下载：{0}", pair.Key);
        }
        return this;
    }
 
    //停止下载
    public void Stop()
    {
        startTickcount = 0;
        isBegin = false;
        foreach (var pair in downloadTask)
        {
            pair.Value.Stop();//停止所有下载任务
        }
    }
 
    private void Update()
    {
        if (!isBegin)
            return;
        if (waitTask.Count == 0)
            return;
        if (downloadTask.Count >= MaxDownLoadTask)
            return;
        
        //Debug.LogFormat("下载最大任务：{0}", MaxDownLoadTask);
        var task = waitTask.Dequeue();
        if (task.IsDone)
            return;
        //开始下载
        if (!downloadTask.ContainsKey(task.Key))
            downloadTask.Add(task.Key, task);
        task.BeginDownload(OnTaskCompleted);
    }
 
    // 任务下载完成
    private void OnTaskCompleted(DownloadHotTask task)
    {
        downloadTask.Remove(task.Key);
        if (task.IsDone)//下载成功
        {
            finishedBytes += task.downloadedBytes;
            allTask.Remove(task.Key);
            this.onTaskCompleted?.Invoke(IsFinished, task);
        }
        else//下载失败
        {
            var prior = this.onTaskCompleted == null ? false : this.onTaskCompleted(IsFinished, task);//返回值为是否立即重试
            //所有任务中不存在，说明已经被清除了,就不重新排队
            if (allTask.ContainsKey(task.Key))
            {
                if (prior) //不排队，直接重新开始
                {
                    downloadTask.Add(task.Key, task);
                    if (isBegin)
                        task.BeginDownload(OnTaskCompleted);
                }
                else
                    waitTask.Enqueue(task); //重新排队
            }
        }
        //TODO:这里暂时用无限重复下载，不做上限处理
        // if (task.failedTimes >= MaxRetryTimes)//重试次数已达到上限，任务失败
        // task.team.OnFailed(task);
        // else//重试次数未达到上限,重新加入等待队列
        // waitTask.Enqueue(task);
    }
}
 
 
 
public class DownloadHotTask
{
    //下载任务状态
    public enum TaskState
    {
        Wait,
        Working,
        Succeed,
        Failed
    }
    public readonly string remoteUrl; //远程连接地址
    public readonly string localFile; //本地地址
    public readonly string tempFile;//临时文件地址
    private readonly bool clearCache;//是否清除旧的下载缓存，（断点续传）
    public readonly object obj; //自定义对象
    private Action<DownloadHotTask> onCompleted;//下载完成回调
    private TaskState state;//下载状态
 
    public bool isStop;//下载被停止
    public int failedTimes = 0;//失败的次数
    private bool requestHeaderOk = false;//是否已获取头信息
    private System.DateTime remoteLastModified; //远端文件最后修改时间
    public long remoteLength;//远端文件大小
    private bool isAcceptRange = false;//服务端是否支持断点续传
    private string errorStr;//错误信息
    public long downloadedBytes;//当前已下载数据
    public float downloadedSpeed;//当前下载速度
    private int beginTickCount;
 
    private UnityWebRequest fileRequest;
 
    public string Key { get { return remoteUrl; } }
 
    public string SpeedFormat { get { return StringUtility.FormatSpeed(downloadedSpeed); } }
 
    //本地文件大小
    public long LocalLength { get { return (File.Exists(tempFile)) ? (new FileInfo(tempFile)).Length : 0L; } }
 
    //本地文件最后修改时间
    private System.DateTime LocalLastModified { get { return File.Exists(tempFile) ? File.GetLastWriteTime(tempFile) : DateTime.MinValue; } }
    public bool IsWorking { get { return state == TaskState.Working; } }
    public bool IsDone { get { return state == TaskState.Succeed; } }
 
    /// <summary>
    /// 
    /// </summary>
    /// <param name="remoteUrl">下载地址</param>
    /// <param name="localUrl">本地保存地址</param>
    /// <param name="obj">自定义对象</param>
    /// <param name="clearCache">是否清除上次下载的缓存</param>
    public DownloadHotTask(string remoteUrl, string localUrl, object obj = null, bool clearCache = false)
    {
        this.remoteUrl = remoteUrl;
        this.localFile = localUrl;
        this.tempFile = localFile + ".temp";
        this.obj = obj;
        this.clearCache = clearCache;
        this.state = TaskState.Wait;
    }
 
    private bool IsOutdated //本地文件是否已过时
    {
        get {
            if (File.Exists(tempFile))
                return remoteLastModified > LocalLastModified;
            return false;
        }
    }
 
    private void SetSucceed()
    {
        state = TaskState.Succeed;
    }
 
    private void SetFailed(string error)
    {
        this.state = TaskState.Failed;
        this.errorStr = error;
        this.failedTimes++;
    }
 
    public void BeginGetHeader()
    {
        if (IsWorking)
            return;
 
        Co_GetHeader().Forget();
        // SnxxzGame.Instance.StartCoroutine(Co_GetHeader());
    }
 
    public bool BeginDownload(Action<DownloadHotTask> onCompleted)
    {
        if ((IsWorking && requestHeaderOk) || IsDone)//已经在下载任务中或已经下载完成了
            return false;
        if (state == TaskState.Wait)//第一次尝试
            failedTimes = 0;
        this.onCompleted = onCompleted;
        this.isStop = false;
        Co_DownloadFile().Forget();
        // SnxxzGame.Instance.StartCoroutine(Co_DownloadFile());
        return true;
    }
 
    //停止下载
    public void Stop()
    {
        isStop = true;
        if (fileRequest != null && !fileRequest.isDone)
            fileRequest.Abort();
        Debug.LogFormat("暂停任务：{0}", remoteUrl);
    }
 
    //获取文件头信息
    private async UniTask Co_GetHeader()
    {
        this.state = TaskState.Working;
        FileExtersion.MakeSureDirectory(tempFile);
        Debug.LogFormat("开始获取头信息：{0}", remoteUrl);
        using (var www = UnityWebRequest.Head(remoteUrl))
        {
            www.timeout = DownloadHotMgr.TimeOut;
            await www.SendWebRequest();
            if (www.result == UnityWebRequest.Result.ConnectionError || www.result == UnityWebRequest.Result.ProtocolError)
            {
                Debug.LogErrorFormat("头信息获取失败：{0}；error：{1}", remoteUrl, www.error);
                requestHeaderOk = false;
                SetFailed(www.error);
                www.Dispose();
                await UniTask.CompletedTask;
            }
            long.TryParse(www.GetResponseHeader(HttpHeader.ContentLength), out this.remoteLength);
            this.remoteLastModified = DateTime.Parse(www.GetResponseHeader(HttpHeader.LastModified));
            var acceptRange = www.GetResponseHeader(HttpHeader.AcceptRanges);
            this.isAcceptRange = acceptRange != "none";
            Debug.LogFormat("头信息获取成功：{0}；大小：{1}；修改时间：{2}；是否支持续传：{3}", remoteUrl, remoteLength, remoteLastModified, acceptRange);
            requestHeaderOk = true;
            state = TaskState.Wait;
            www.Dispose();
        }
    }
    private async UniTask Co_DownloadFile()
    {
        state = TaskState.Working;
        while (TimeUtility.AllSeconds < beginTickCount + 5)//限制重新下载的时间间隔
        {
            if (isStop)
                await UniTask.CompletedTask;
            else
                await UniTask.DelayFrame(1);
        }
        beginTickCount = TimeUtility.AllSeconds;
        if (!requestHeaderOk)
            await Co_GetHeader();
        if (!requestHeaderOk)//头文件获取失败
        {
            onCompleted?.Invoke(this);
            await UniTask.CompletedTask;
        }
        try
        {
            if (clearCache && File.Exists(tempFile))
            {
                File.Delete(localFile);//清除上次下载的临时文件
                Debug.LogFormat("已清除缓存文件：{0}", tempFile);
            }
        }
        catch (Exception e)
        {
            Debug.LogFormat("清除缓存文件失败：{0}；error：{1}", tempFile, e);
        }
        if (File.Exists(tempFile))//临时文件存在
        {
            var _localLength = LocalLength;
            var _outdated = IsOutdated;
            //文件完整且未过期，无须再下载了
            if (_localLength == remoteLength && !_outdated)
            {
                await Move(tempFile, localFile);//把临时文件改名为正式文件
                onCompleted?.Invoke(this);
                await UniTask.CompletedTask;
            }
            else if (_localLength > remoteLength || _outdated)//文件不对或过期了
            {
                if (!_outdated) Debug.LogFormat("本地文件大于服务器端文件：{0}", tempFile);
                if (_outdated) Debug.LogFormat("文件已过期：{0}", tempFile);
                try
                {
                    if (File.Exists(tempFile))
                        File.Delete(tempFile);
                }
                catch (Exception e)
                {
                    Debug.LogErrorFormat("删除临时文件出错：{0}；error：{1}", tempFile, e);
                    isAcceptRange = false;//如果删除临时文件出错，取消续传，覆写文件
                }
            }
        }
        if (isStop)//任务被暂停
        {
            state = TaskState.Wait;
            await UniTask.CompletedTask;
        }
        Debug.LogFormat("下载任务开始：{0}", remoteUrl);
        fileRequest = UnityWebRequest.Get(remoteUrl);
 
        fileRequest.downloadHandler = new DownloadHandlerFile(tempFile, this.isAcceptRange);
        if (LocalLength != 0L && isAcceptRange)
            fileRequest.SetRequestHeader(HttpHeader.Range, "bytes=" + LocalLength + "-");
        Debug.LogFormat("下载请求范围：{0} ；bytes={1}", remoteUrl, LocalLength);
        var localLength = LocalLength;
        this.downloadedBytes = localLength;
        fileRequest.SendWebRequest();
        while (!fileRequest.isDone)
        {
            var length = localLength + (long)fileRequest.downloadedBytes;//本地文件大小+本次下载的数据大小
            this.downloadedSpeed = Math.Max(0, (length - this.downloadedBytes) / Time.deltaTime);
            this.downloadedBytes = length;
            await UniTask.DelayFrame(1);
        }
        if (fileRequest.result == UnityWebRequest.Result.ConnectionError || fileRequest.result == UnityWebRequest.Result.ProtocolError)
        {
            if (isStop)//任务被暂停
            {
                state = TaskState.Wait;
            }
            else //任务失败
            {
                SetFailed(fileRequest.error);
                onCompleted?.Invoke(this);
                Debug.LogErrorFormat("文件下载失败：{0}；error：{1}", remoteUrl, fileRequest.error);
            }
            fileRequest.Dispose();
            fileRequest = null;
            await UniTask.CompletedTask;
        }
        Debug.LogFormat("文件下载成功：{0}；", tempFile);
        fileRequest.Dispose();
        fileRequest = null;
 
        FileInfo tempFileInfo = new FileInfo(tempFile);
        if (tempFileInfo.Exists)
        {
            //判断临时文件和远程文件大小是否一致
            if (tempFileInfo.Length != remoteLength && remoteLength != 0L)
            {
                Debug.LogErrorFormat("下载完成后但是大小不一致：{0}； {1} || {2}", remoteUrl, tempFileInfo.Length, remoteLastModified);
                SetFailed("文件下载完成后但是大小不一致");
            }
            else
            {  //大小一致 
                await Move(tempFile, localFile);
            }
        }
        else
        {   //临时文件不存在
            Debug.LogErrorFormat("下载完成但是临时文件不存在：{0}", tempFile);
            SetFailed("下载完成但是文件不存在");
        }
        onCompleted?.Invoke(this);
    }
 
    private async UniTask Move(string sourceFile, string destFile)
    {
 
        var copyState = 0;//复制文件状态，0等待，1成功，2失败
        try
        {
            if (File.Exists(destFile))
                File.Delete(destFile);
            File.Move(sourceFile, destFile);
            copyState = 1;
        }
        catch (Exception e)
        {
            Debug.LogErrorFormat("拷贝文件出错：{0}；error：{1}", destFile, e);
            copyState = 2;
        }
 
        if (copyState == 1)
        {
            Debug.LogFormat("文件复制成功：{0}", localFile);
            SetSucceed();
        }
        else
            SetFailed("临时文件改名出错");
 
        await UniTask.CompletedTask;
    }
 
}