TE6 打飞机Demo

TE6 打飞机Demo

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/ApplicationFootPrint.cs

@@ -0,0 +1,63 @@
+using System.IO;
+using UnityEngine;
+
+namespace YooAsset
+{
+    /// <summary>
+    /// 应用程序水印
+    /// </summary>
+    internal class ApplicationFootPrint
+    {
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private string _footPrint;
+
+
+        public ApplicationFootPrint(DefaultCacheFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+        }
+
+        /// <summary>
+        /// 读取应用程序水印
+        /// </summary>
+        public void Load(string packageName)
+        {
+            string footPrintFilePath = _fileSystem.GetSandboxAppFootPrintFilePath();
+            if (File.Exists(footPrintFilePath))
+            {
+                _footPrint = FileUtility.ReadAllText(footPrintFilePath);
+            }
+            else
+            {
+                Coverage(packageName);
+            }
+        }
+
+        /// <summary>
+        /// 检测水印是否发生变化
+        /// </summary>
+        public bool IsDirty()
+        {
+#if UNITY_EDITOR
+            return _footPrint != Application.version;
+#else
+		    return _footPrint != Application.buildGUID;
+#endif
+        }
+
+        /// <summary>
+        /// 覆盖掉水印
+        /// </summary>
+        public void Coverage(string packageName)
+        {
+#if UNITY_EDITOR
+            _footPrint = Application.version;
+#else
+			_footPrint = Application.buildGUID;
+#endif
+            string footPrintFilePath = _fileSystem.GetSandboxAppFootPrintFilePath();
+            FileUtility.WriteAllText(footPrintFilePath, _footPrint);
+            YooLogger.Log($"Save application foot print : {_footPrint}");
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/ApplicationFootPrint.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c9d96ea955bc07149a08471e33915556
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/DefaultCacheFileSystem.cs

@@ -0,0 +1,564 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace YooAsset
+{
+    /// <summary>
+    /// 缓存文件系统
+    /// 说明：正在进行的下载器会在ResourcePackage销毁的时候执行Abort操作！
+    /// </summary>
+    internal class DefaultCacheFileSystem : IFileSystem
+    {
+        protected readonly Dictionary<string, RecordFileElement> _records = new Dictionary<string, RecordFileElement>(10000);
+        protected readonly Dictionary<string, string> _bundleDataFilePathMapping = new Dictionary<string, string>(10000);
+        protected readonly Dictionary<string, string> _bundleInfoFilePathMapping = new Dictionary<string, string>(10000);
+        protected readonly Dictionary<string, string> _tempFilePathMapping = new Dictionary<string, string>(10000);
+
+        protected string _packageRoot;
+        protected string _tempFilesRoot;
+        protected string _cacheBundleFilesRoot;
+        protected string _cacheManifestFilesRoot;
+
+        /// <summary>
+        /// 下载中心
+        /// 说明：当异步操作任务终止的时候，所有下载子任务都会一同被终止！
+        /// </summary>
+        public DownloadCenterOperation DownloadCenter { set; get; }
+
+        /// <summary>
+        /// 包裹名称
+        /// </summary>
+        public string PackageName { private set; get; }
+
+        /// <summary>
+        /// 文件根目录
+        /// </summary>
+        public string FileRoot
+        {
+            get
+            {
+                return _packageRoot;
+            }
+        }
+
+        /// <summary>
+        /// 文件数量
+        /// </summary>
+        public int FileCount
+        {
+            get
+            {
+                return _records.Count;
+            }
+        }
+
+        #region 自定义参数
+        /// <summary>
+        /// 自定义参数：远程服务接口
+        /// </summary>
+        public IRemoteServices RemoteServices { private set; get; } = null;
+
+        /// <summary>
+        /// 自定义参数：初始化的时候缓存文件校验级别
+        /// </summary>
+        public EFileVerifyLevel FileVerifyLevel { private set; get; } = EFileVerifyLevel.Middle;
+
+        /// <summary>
+        /// 自定义参数：覆盖安装缓存清理模式
+        /// </summary>
+        public EOverwriteInstallClearMode InstallClearMode { private set; get; } = EOverwriteInstallClearMode.ClearAllManifestFiles;
+
+        /// <summary>
+        /// 自定义参数：数据文件追加文件格式
+        /// </summary>
+        public bool AppendFileExtension { private set; get; } = false;
+
+        /// <summary>
+        /// 自定义参数：最大并发连接数
+        /// </summary>
+        public int DownloadMaxConcurrency { private set; get; } = int.MaxValue;
+
+        /// <summary>
+        /// 自定义参数：每帧发起的最大请求数
+        /// </summary>
+        public int DownloadMaxRequestPerFrame { private set; get; } = int.MaxValue;
+
+        /// <summary>
+        /// 自定义参数：启用断点续传的最小尺寸
+        /// </summary>
+        public long ResumeDownloadMinimumSize { private set; get; } = long.MaxValue;
+
+        /// <summary>
+        /// 自定义参数：断点续传下载器关注的错误码
+        /// </summary>
+        public List<long> ResumeDownloadResponseCodes { private set; get; } = null;
+
+        /// <summary>
+        ///  自定义参数：解密方法类
+        /// </summary>
+        public IDecryptionServices DecryptionServices { private set; get; }
+        #endregion
+
+
+        public DefaultCacheFileSystem()
+        {
+        }
+        public virtual FSInitializeFileSystemOperation InitializeFileSystemAsync()
+        {
+            var operation = new DCFSInitializeOperation(this);
+            return operation;
+        }
+        public virtual FSLoadPackageManifestOperation LoadPackageManifestAsync(string packageVersion, int timeout)
+        {
+            var operation = new DCFSLoadPackageManifestOperation(this, packageVersion, timeout);
+            return operation;
+        }
+        public virtual FSRequestPackageVersionOperation RequestPackageVersionAsync(bool appendTimeTicks, int timeout)
+        {
+            var operation = new DCFSRequestPackageVersionOperation(this, appendTimeTicks, timeout);
+            return operation;
+        }
+        public virtual FSClearCacheFilesOperation ClearCacheFilesAsync(PackageManifest manifest, ClearCacheFilesOptions options)
+        {
+            if (options.ClearMode == EFileClearMode.ClearAllBundleFiles.ToString())
+            {
+                var operation = new ClearAllCacheBundleFilesOperation(this);
+                return operation;
+            }
+            else if (options.ClearMode == EFileClearMode.ClearUnusedBundleFiles.ToString())
+            {
+                var operation = new ClearUnusedCacheBundleFilesOperation(this, manifest);
+                return operation;
+            }
+            else if (options.ClearMode == EFileClearMode.ClearBundleFilesByTags.ToString())
+            {
+                var operation = new ClearCacheBundleFilesByTagsOperaiton(this, manifest, options.ClearParam);
+                return operation;
+            }
+            else if (options.ClearMode == EFileClearMode.ClearAllManifestFiles.ToString())
+            {
+                var operation = new ClearAllCacheManifestFilesOperation(this);
+                return operation;
+            }
+            else if (options.ClearMode == EFileClearMode.ClearUnusedManifestFiles.ToString())
+            {
+                var operation = new ClearUnusedCacheManifestFilesOperation(this, manifest);
+                return operation;
+            }
+            else
+            {
+                string error = $"Invalid clear mode : {options.ClearMode}";
+                var operation = new FSClearCacheFilesCompleteOperation(error);
+                return operation;
+            }
+        }
+        public virtual FSDownloadFileOperation DownloadFileAsync(PackageBundle bundle, DownloadFileOptions options)
+        {
+            var downloader = DownloadCenter.DownloadFileAsync(bundle, options);
+            downloader.Reference(); //增加下载器的引用计数
+
+            // 注意：将下载器进行包裹，可以避免父类任务终止的时候，连带子任务里的下载器也一起被终止！
+            var wrapper = new DownloadFileWrapper(downloader);
+            return wrapper;
+        }
+        public virtual FSLoadBundleOperation LoadBundleFile(PackageBundle bundle)
+        {
+            if (bundle.BundleType == (int)EBuildBundleType.AssetBundle)
+            {
+                var operation = new DCFSLoadAssetBundleOperation(this, bundle);
+                return operation;
+            }
+            else if (bundle.BundleType == (int)EBuildBundleType.RawBundle)
+            {
+                var operation = new DCFSLoadRawBundleOperation(this, bundle);
+                return operation;
+            }
+            else
+            {
+                string error = $"{nameof(DefaultCacheFileSystem)} not support load bundle type : {bundle.BundleType}";
+                var operation = new FSLoadBundleCompleteOperation(error);
+                return operation;
+            }
+        }
+
+        public virtual void SetParameter(string name, object value)
+        {
+            if (name == FileSystemParametersDefine.REMOTE_SERVICES)
+            {
+                RemoteServices = (IRemoteServices)value;
+            }
+            else if (name == FileSystemParametersDefine.FILE_VERIFY_LEVEL)
+            {
+                FileVerifyLevel = (EFileVerifyLevel)value;
+            }
+            else if (name == FileSystemParametersDefine.INSTALL_CLEAR_MODE)
+            {
+                InstallClearMode = (EOverwriteInstallClearMode)value;
+            }
+            else if (name == FileSystemParametersDefine.APPEND_FILE_EXTENSION)
+            {
+                AppendFileExtension = Convert.ToBoolean(value);
+            }
+            else if (name == FileSystemParametersDefine.DOWNLOAD_MAX_CONCURRENCY)
+            {
+                DownloadMaxConcurrency = Convert.ToInt32(value);
+            }
+            else if (name == FileSystemParametersDefine.DOWNLOAD_MAX_REQUEST_PER_FRAME)
+            {
+                DownloadMaxRequestPerFrame = Convert.ToInt32(value);
+            }
+            else if (name == FileSystemParametersDefine.RESUME_DOWNLOAD_MINMUM_SIZE)
+            {
+                ResumeDownloadMinimumSize = Convert.ToInt64(value);
+            }
+            else if (name == FileSystemParametersDefine.RESUME_DOWNLOAD_RESPONSE_CODES)
+            {
+                ResumeDownloadResponseCodes = (List<long>)value;
+            }
+            else if (name == FileSystemParametersDefine.DECRYPTION_SERVICES)
+            {
+                DecryptionServices = (IDecryptionServices)value;
+            }
+            else
+            {
+                YooLogger.Warning($"Invalid parameter : {name}");
+            }
+        }
+        public virtual void OnCreate(string packageName, string packageRoot)
+        {
+            PackageName = packageName;
+
+            if (string.IsNullOrEmpty(packageRoot))
+                _packageRoot = GetDefaultCachePackageRoot(packageName);
+            else
+                _packageRoot = packageRoot;
+
+            _cacheBundleFilesRoot = PathUtility.Combine(_packageRoot, DefaultCacheFileSystemDefine.BundleFilesFolderName);
+            _cacheManifestFilesRoot = PathUtility.Combine(_packageRoot, DefaultCacheFileSystemDefine.ManifestFilesFolderName);
+            _tempFilesRoot = PathUtility.Combine(_packageRoot, DefaultCacheFileSystemDefine.TempFilesFolderName);
+        }
+        public virtual void OnDestroy()
+        {
+            if (DownloadCenter != null)
+            {
+                DownloadCenter.AbortOperation();
+                DownloadCenter = null;
+            }
+        }
+
+        public virtual bool Belong(PackageBundle bundle)
+        {
+            // 注意：缓存文件系统保底加载！
+            return true;
+        }
+        public virtual bool Exists(PackageBundle bundle)
+        {
+            return _records.ContainsKey(bundle.BundleGUID);
+        }
+        public virtual bool NeedDownload(PackageBundle bundle)
+        {
+            if (Belong(bundle) == false)
+                return false;
+
+            return Exists(bundle) == false;
+        }
+        public virtual bool NeedUnpack(PackageBundle bundle)
+        {
+            return false;
+        }
+        public virtual bool NeedImport(PackageBundle bundle)
+        {
+            if (Belong(bundle) == false)
+                return false;
+
+            return Exists(bundle) == false;
+        }
+
+        public virtual string GetBundleFilePath(PackageBundle bundle)
+        {
+            return GetCacheBundleFileLoadPath(bundle);
+        }
+        public virtual byte[] ReadBundleFileData(PackageBundle bundle)
+        {
+            if (Exists(bundle) == false)
+                return null;
+
+            if (bundle.Encrypted)
+            {
+                if (DecryptionServices == null)
+                {
+                    YooLogger.Error($"The {nameof(IDecryptionServices)} is null !");
+                    return null;
+                }
+
+                string filePath = GetCacheBundleFileLoadPath(bundle);
+                var fileInfo = new DecryptFileInfo()
+                {
+                    BundleName = bundle.BundleName,
+                    FileLoadCRC = bundle.UnityCRC,
+                    FileLoadPath = filePath,
+                };
+                return DecryptionServices.ReadFileData(fileInfo);
+            }
+            else
+            {
+                string filePath = GetCacheBundleFileLoadPath(bundle);
+                return FileUtility.ReadAllBytes(filePath);
+            }
+        }
+        public virtual string ReadBundleFileText(PackageBundle bundle)
+        {
+            if (Exists(bundle) == false)
+                return null;
+
+            if (bundle.Encrypted)
+            {
+                if (DecryptionServices == null)
+                {
+                    YooLogger.Error($"The {nameof(IDecryptionServices)} is null !");
+                    return null;
+                }
+
+                string filePath = GetCacheBundleFileLoadPath(bundle);
+                var fileInfo = new DecryptFileInfo()
+                {
+                    BundleName = bundle.BundleName,
+                    FileLoadCRC = bundle.UnityCRC,
+                    FileLoadPath = filePath,
+                };
+                return DecryptionServices.ReadFileText(fileInfo);
+            }
+            else
+            {
+                string filePath = GetCacheBundleFileLoadPath(bundle);
+                return FileUtility.ReadAllText(filePath);
+            }
+        }
+
+        #region 缓存相关
+        public List<string> GetAllCachedBundleGUIDs()
+        {
+            return _records.Keys.ToList();
+        }
+        public RecordFileElement GetRecordFileElement(PackageBundle bundle)
+        {
+            if (_records.TryGetValue(bundle.BundleGUID, out RecordFileElement element))
+                return element;
+            else
+                return null;
+        }
+
+        public string GetTempFilePath(PackageBundle bundle)
+        {
+            if (_tempFilePathMapping.TryGetValue(bundle.BundleGUID, out string filePath) == false)
+            {
+                filePath = PathUtility.Combine(_tempFilesRoot, bundle.BundleGUID);
+                _tempFilePathMapping.Add(bundle.BundleGUID, filePath);
+            }
+            return filePath;
+        }
+        public string GetBundleDataFilePath(PackageBundle bundle)
+        {
+            if (_bundleDataFilePathMapping.TryGetValue(bundle.BundleGUID, out string filePath) == false)
+            {
+                string folderName = bundle.FileHash.Substring(0, 2);
+                filePath = PathUtility.Combine(_cacheBundleFilesRoot, folderName, bundle.BundleGUID, DefaultCacheFileSystemDefine.BundleDataFileName);
+                if (AppendFileExtension)
+                    filePath += bundle.FileExtension;
+                _bundleDataFilePathMapping.Add(bundle.BundleGUID, filePath);
+            }
+            return filePath;
+        }
+        public string GetBundleInfoFilePath(PackageBundle bundle)
+        {
+            if (_bundleInfoFilePathMapping.TryGetValue(bundle.BundleGUID, out string filePath) == false)
+            {
+                string folderName = bundle.FileHash.Substring(0, 2);
+                filePath = PathUtility.Combine(_cacheBundleFilesRoot, folderName, bundle.BundleGUID, DefaultCacheFileSystemDefine.BundleInfoFileName);
+                _bundleInfoFilePathMapping.Add(bundle.BundleGUID, filePath);
+            }
+            return filePath;
+        }
+
+        public bool IsRecordBundleFile(string bundleGUID)
+        {
+            return _records.ContainsKey(bundleGUID);
+        }
+        public bool RecordBundleFile(string bundleGUID, RecordFileElement element)
+        {
+            if (_records.ContainsKey(bundleGUID))
+            {
+                YooLogger.Error($"{nameof(DefaultCacheFileSystem)} has element : {bundleGUID}");
+                return false;
+            }
+
+            _records.Add(bundleGUID, element);
+            return true;
+        }
+
+        public EFileVerifyResult VerifyCacheFile(PackageBundle bundle)
+        {
+            if (_records.TryGetValue(bundle.BundleGUID, out RecordFileElement element) == false)
+                return EFileVerifyResult.CacheNotFound;
+
+            EFileVerifyResult result = FileVerifyHelper.FileVerify(element.DataFilePath, element.DataFileSize, element.DataFileCRC, EFileVerifyLevel.High);
+            return result;
+        }
+        public bool WriteCacheBundleFile(PackageBundle bundle, string copyPath)
+        {
+            if (_records.ContainsKey(bundle.BundleGUID))
+            {
+                throw new Exception("Should never get here !");
+            }
+
+            string infoFilePath = GetBundleInfoFilePath(bundle);
+            string dataFilePath = GetBundleDataFilePath(bundle);
+
+            try
+            {
+                if (File.Exists(infoFilePath))
+                    File.Delete(infoFilePath);
+                if (File.Exists(dataFilePath))
+                    File.Delete(dataFilePath);
+
+                FileUtility.CreateFileDirectory(dataFilePath);
+
+                // 拷贝数据文件
+                FileInfo fileInfo = new FileInfo(copyPath);
+                fileInfo.CopyTo(dataFilePath);
+
+                // 写入文件信息
+                WriteBundleInfoFile(infoFilePath, bundle.FileCRC, bundle.FileSize);
+            }
+            catch (Exception e)
+            {
+                YooLogger.Error($"Failed to write cache file ! {e.Message}");
+                return false;
+            }
+
+            var recordFileElement = new RecordFileElement(infoFilePath, dataFilePath, bundle.FileCRC, bundle.FileSize);
+            return RecordBundleFile(bundle.BundleGUID, recordFileElement);
+        }
+        public bool DeleteCacheBundleFile(string bundleGUID)
+        {
+            if (_records.TryGetValue(bundleGUID, out RecordFileElement element))
+            {
+                _records.Remove(bundleGUID);
+                return element.DeleteFolder();
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        private readonly BufferWriter _sharedBuffer = new BufferWriter(1024);
+        public void WriteBundleInfoFile(string filePath, string dataFileCRC, long dataFileSize)
+        {
+            using (FileStream fs = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.Read))
+            {
+                _sharedBuffer.Clear();
+                _sharedBuffer.WriteUTF8(dataFileCRC);
+                _sharedBuffer.WriteInt64(dataFileSize);
+                _sharedBuffer.WriteToStream(fs);
+                fs.Flush();
+            }
+        }
+        public void ReadBundleInfoFile(string filePath, out string dataFileCRC, out long dataFileSize)
+        {
+            byte[] binaryData = FileUtility.ReadAllBytes(filePath);
+            BufferReader buffer = new BufferReader(binaryData);
+            dataFileCRC = buffer.ReadUTF8();
+            dataFileSize = buffer.ReadInt64();
+        }
+        #endregion
+
+        #region 内部方法
+        public string GetDefaultCachePackageRoot(string packageName)
+        {
+            string rootDirectory = YooAssetSettingsData.GetYooDefaultCacheRoot();
+            return PathUtility.Combine(rootDirectory, packageName);
+        }
+        public string GetCacheBundleFileLoadPath(PackageBundle bundle)
+        {
+            return GetBundleDataFilePath(bundle);
+        }
+        public string GetCachePackageHashFilePath(string packageVersion)
+        {
+            string fileName = YooAssetSettingsData.GetPackageHashFileName(PackageName, packageVersion);
+            return PathUtility.Combine(_cacheManifestFilesRoot, fileName);
+        }
+        public string GetCachePackageManifestFilePath(string packageVersion)
+        {
+            string fileName = YooAssetSettingsData.GetManifestBinaryFileName(PackageName, packageVersion);
+            return PathUtility.Combine(_cacheManifestFilesRoot, fileName);
+        }
+        public string GetSandboxAppFootPrintFilePath()
+        {
+            return PathUtility.Combine(_cacheManifestFilesRoot, DefaultCacheFileSystemDefine.AppFootPrintFileName);
+        }
+        public string GetCacheBundleFilesRoot()
+        {
+            return _cacheBundleFilesRoot;
+        }
+        public string GetCacheManifestFilesRoot()
+        {
+            return _cacheManifestFilesRoot;
+        }
+
+        /// <summary>
+        /// 删除所有缓存的资源文件
+        /// </summary>
+        public void DeleteAllBundleFiles()
+        {
+            if (Directory.Exists(_cacheBundleFilesRoot))
+            {
+                Directory.Delete(_cacheBundleFilesRoot, true);
+            }
+        }
+
+        /// <summary>
+        /// 删除所有缓存的清单文件
+        /// </summary>
+        public void DeleteAllManifestFiles()
+        {
+            if (Directory.Exists(_cacheManifestFilesRoot))
+            {
+                Directory.Delete(_cacheManifestFilesRoot, true);
+            }
+        }
+
+        /// <summary>
+        /// 加载加密资源文件
+        /// </summary>
+        public DecryptResult LoadEncryptedAssetBundle(PackageBundle bundle)
+        {
+            string filePath = GetCacheBundleFileLoadPath(bundle);
+            var fileInfo = new DecryptFileInfo()
+            {
+                BundleName = bundle.BundleName,
+                FileLoadCRC = bundle.UnityCRC,
+                FileLoadPath = filePath,
+            };
+            return DecryptionServices.LoadAssetBundle(fileInfo);
+        }
+
+        /// <summary>
+        /// 加载加密资源文件
+        /// </summary>
+        public DecryptResult LoadEncryptedAssetBundleAsync(PackageBundle bundle)
+        {
+            string filePath = GetCacheBundleFileLoadPath(bundle);
+            var fileInfo = new DecryptFileInfo()
+            {
+                BundleName = bundle.BundleName,
+                FileLoadCRC = bundle.UnityCRC,
+                FileLoadPath = filePath,
+            };
+            return DecryptionServices.LoadAssetBundleAsync(fileInfo);
+        }
+        #endregion
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/DefaultCacheFileSystem.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4989ddcb6c99102429eeefffc3675ae5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/DefaultCacheFileSystemDefine.cs

@@ -0,0 +1,36 @@
+
+namespace YooAsset
+{
+    internal class DefaultCacheFileSystemDefine
+    {
+        /// <summary>
+        /// 数据文件名称
+        /// </summary>
+        public const string BundleDataFileName = "__data";
+
+        /// <summary>
+        /// 信息文件名称
+        /// </summary>
+        public const string BundleInfoFileName = "__info";
+
+        /// <summary>
+        /// 资源文件的文件夹名称
+        /// </summary>
+        public const string BundleFilesFolderName = "BundleFiles";
+
+        /// <summary>
+        /// 临时文件的文件夹名称
+        /// </summary>
+        public const string TempFilesFolderName = "TempFiles";
+
+        /// <summary>
+        /// 清单文件的文件夹名称
+        /// </summary>
+        public const string ManifestFilesFolderName = "ManifestFiles";
+
+        /// <summary>
+        /// 记录应用程序版本的文件名称
+        /// </summary>
+        public const string AppFootPrintFileName = "ApplicationFootPrint.bytes";
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/DefaultCacheFileSystemDefine.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 610912866fe58794a904b43c2e24d84d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/EOverwriteInstallClearMode.cs

@@ -0,0 +1,29 @@
+
+namespace YooAsset
+{
+    /// <summary>
+    /// 覆盖安装清理模式
+    /// </summary>
+    public enum EOverwriteInstallClearMode
+    {
+        /// <summary>
+        /// 不做任何处理
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// 清理所有缓存文件（包含资源文件和清单文件）
+        /// </summary>
+        ClearAllCacheFiles = 1,
+
+        /// <summary>
+        /// 清理所有缓存的资源文件
+        /// </summary>
+        ClearAllBundleFiles = 2,
+
+        /// <summary>
+        /// 清理所有缓存的清单文件
+        /// </summary>
+        ClearAllManifestFiles = 3,
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/EOverwriteInstallClearMode.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c61fdc079dca97548a0158b8100ec258
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Elements.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: da6402a4b93d31943b26fb99cebc0dfd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Elements/RecordFileElement.cs

@@ -0,0 +1,47 @@
+using System;
+using System.IO;
+
+namespace YooAsset
+{
+    internal class RecordFileElement
+    {
+        public string InfoFilePath { private set; get; }
+        public string DataFilePath { private set; get; }
+        public string DataFileCRC { private set; get; }
+        public long DataFileSize { private set; get; }
+
+        public RecordFileElement(string infoFilePath, string dataFilePath, string dataFileCRC, long dataFileSize)
+        {
+            InfoFilePath = infoFilePath;
+            DataFilePath = dataFilePath;
+            DataFileCRC = dataFileCRC;
+            DataFileSize = dataFileSize;
+        }
+
+        /// <summary>
+        /// 删除记录文件
+        /// </summary>
+        public bool DeleteFolder()
+        {
+            try
+            {
+                string directory = Path.GetDirectoryName(InfoFilePath);
+                DirectoryInfo directoryInfo = new DirectoryInfo(directory);
+                if (directoryInfo.Exists)
+                {
+                    directoryInfo.Delete(true);
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            catch (Exception e)
+            {
+                YooLogger.Error($"Failed to delete cache file ! {e.Message}");
+                return false;
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Elements/RecordFileElement.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ae2176c4ea6fbb3478bf8757def34cd7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Elements/TempFileElement.cs

@@ -0,0 +1,22 @@
+
+namespace YooAsset
+{
+    internal class TempFileElement
+    {
+        public string TempFilePath { private set; get; }
+        public string TempFileCRC { private set; get; }
+        public long TempFileSize { private set; get; }
+
+        /// <summary>
+        /// 注意：原子操作对象
+        /// </summary>
+        public volatile int Result = 0;
+
+        public TempFileElement(string filePath, string fileCRC, long fileSize)
+        {
+            TempFilePath = filePath;
+            TempFileCRC = fileCRC;
+            TempFileSize = fileSize;
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Elements/TempFileElement.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 220136fdc4a13d84e97b1249cfc65f3b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Elements/VerifyFileElement.cs

@@ -0,0 +1,42 @@
+using System.IO;
+
+namespace YooAsset
+{
+    internal class VerifyFileElement
+    {
+        public string PackageName { private set; get; }
+        public string BundleGUID { private set; get; }
+        public string FileRootPath { private set; get; }
+        public string DataFilePath { private set; get; }
+        public string InfoFilePath { private set; get; }
+
+        public string DataFileCRC;
+        public long DataFileSize;
+
+        /// <summary>
+        /// 注意：原子操作对象
+        /// </summary>
+        public volatile int Result = 0;
+
+        public VerifyFileElement(string packageName, string bundleGUID, string fileRootPath, string dataFilePath, string infoFilePath)
+        {
+            PackageName = packageName;
+            BundleGUID = bundleGUID;
+            FileRootPath = fileRootPath;
+            DataFilePath = dataFilePath;
+            InfoFilePath = infoFilePath;
+        }
+
+        public void DeleteFiles()
+        {
+            try
+            {
+                Directory.Delete(FileRootPath, true);
+            }
+            catch (System.Exception e)
+            {
+                YooLogger.Warning($"Failed to delete cache bundle folder : {e}");
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Elements/VerifyFileElement.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0c361449cdcbd8746ba3fb948798ae1b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 09e4cebb2073ab945ac09e9099b327ad
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/DCFSInitializeOperation.cs

@@ -0,0 +1,138 @@
+
+namespace YooAsset
+{
+    internal class DCFSInitializeOperation : FSInitializeFileSystemOperation
+    {
+        private enum ESteps
+        {
+            None,
+            CheckAppFootPrint,
+            SearchCacheFiles,
+            VerifyCacheFiles,
+            CreateDownloadCenter,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private SearchCacheFilesOperation _searchCacheFilesOp;
+        private VerifyCacheFilesOperation _verifyCacheFilesOp;
+        private ESteps _steps = ESteps.None;
+
+
+        internal DCFSInitializeOperation(DefaultCacheFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+        }
+        internal override void InternalStart()
+        {
+#if UNITY_WEBGL
+            _steps = ESteps.Done;
+            Status = EOperationStatus.Failed;
+            Error = $"{nameof(DefaultCacheFileSystem)} is not support WEBGL platform !";
+#else
+            _steps = ESteps.CheckAppFootPrint;
+#endif
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.CheckAppFootPrint)
+            {
+                var appFootPrint = new ApplicationFootPrint(_fileSystem);
+                appFootPrint.Load(_fileSystem.PackageName);
+
+                // 如果水印发生变化，则说明覆盖安装后首次打开游戏
+                if (appFootPrint.IsDirty())
+                {
+                    if (_fileSystem.InstallClearMode == EOverwriteInstallClearMode.None)
+                    {
+                        YooLogger.Warning("Do nothing when overwrite install application !");
+                    }
+                    else if (_fileSystem.InstallClearMode == EOverwriteInstallClearMode.ClearAllCacheFiles)
+                    {
+                        _fileSystem.DeleteAllBundleFiles();
+                        _fileSystem.DeleteAllManifestFiles();
+                        YooLogger.Warning("Delete all cache files when overwrite install application !");
+                    }
+                    else if (_fileSystem.InstallClearMode == EOverwriteInstallClearMode.ClearAllBundleFiles)
+                    {
+                        _fileSystem.DeleteAllBundleFiles();
+                        YooLogger.Warning("Delete all bundle files when overwrite install application !");
+                    }
+                    else if (_fileSystem.InstallClearMode == EOverwriteInstallClearMode.ClearAllManifestFiles)
+                    {
+                        _fileSystem.DeleteAllManifestFiles();
+                        YooLogger.Warning("Delete all manifest files when overwrite install application !");
+                    }
+                    else
+                    {
+                        throw new System.NotImplementedException(_fileSystem.InstallClearMode.ToString());
+                    }
+
+                    appFootPrint.Coverage(_fileSystem.PackageName);
+                }
+
+                _steps = ESteps.SearchCacheFiles;
+            }
+
+            if (_steps == ESteps.SearchCacheFiles)
+            {
+                if (_searchCacheFilesOp == null)
+                {
+                    _searchCacheFilesOp = new SearchCacheFilesOperation(_fileSystem);
+                    _searchCacheFilesOp.StartOperation();
+                    AddChildOperation(_searchCacheFilesOp);
+                }
+
+                _searchCacheFilesOp.UpdateOperation();
+                Progress = _searchCacheFilesOp.Progress;
+                if (_searchCacheFilesOp.IsDone == false)
+                    return;
+
+                _steps = ESteps.VerifyCacheFiles;
+            }
+
+            if (_steps == ESteps.VerifyCacheFiles)
+            {
+                if (_verifyCacheFilesOp == null)
+                {
+                    _verifyCacheFilesOp = new VerifyCacheFilesOperation(_fileSystem, _searchCacheFilesOp.Result);
+                    _verifyCacheFilesOp.StartOperation();
+                    AddChildOperation(_verifyCacheFilesOp);
+                }
+
+                _verifyCacheFilesOp.UpdateOperation();
+                Progress = _verifyCacheFilesOp.Progress;
+                if (_verifyCacheFilesOp.IsDone == false)
+                    return;
+
+                if (_verifyCacheFilesOp.Status == EOperationStatus.Succeed)
+                {
+                    _steps = ESteps.CreateDownloadCenter;
+                    YooLogger.Log($"Package '{_fileSystem.PackageName}' cached files count : {_fileSystem.FileCount}");
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = _verifyCacheFilesOp.Error;
+                }
+            }
+
+            if (_steps == ESteps.CreateDownloadCenter)
+            {
+                // 注意：下载中心作为独立任务运行！
+                if (_fileSystem.DownloadCenter == null)
+                {
+                    _fileSystem.DownloadCenter = new DownloadCenterOperation(_fileSystem);
+                    OperationSystem.StartOperation(_fileSystem.PackageName, _fileSystem.DownloadCenter);
+                }
+
+                _steps = ESteps.Done;
+                Status = EOperationStatus.Succeed;
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/DCFSInitializeOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 443aa31f081edfd458a90e3385a75203
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/DCFSLoadBundleOperation.cs

@@ -0,0 +1,361 @@
+using System;
+using System.IO;
+using UnityEngine;
+
+namespace YooAsset
+{
+    internal class DCFSLoadAssetBundleOperation : FSLoadBundleOperation
+    {
+        protected enum ESteps
+        {
+            None,
+            CheckExist,
+            DownloadFile,
+            LoadAssetBundle,
+            CheckResult,
+            Done,
+        }
+
+        protected readonly DefaultCacheFileSystem _fileSystem;
+        protected readonly PackageBundle _bundle;
+        protected FSDownloadFileOperation _downloadFileOp;
+        protected AssetBundleCreateRequest _createRequest;
+        private AssetBundle _assetBundle;
+        private Stream _managedStream;
+        protected ESteps _steps = ESteps.None;
+
+
+        internal DCFSLoadAssetBundleOperation(DefaultCacheFileSystem fileSystem, PackageBundle bundle)
+        {
+            _fileSystem = fileSystem;
+            _bundle = bundle;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.CheckExist;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.CheckExist)
+            {
+                if (_fileSystem.Exists(_bundle))
+                {
+                    DownloadProgress = 1f;
+                    DownloadedBytes = _bundle.FileSize;
+                    _steps = ESteps.LoadAssetBundle;
+                }
+                else
+                {
+                    _steps = ESteps.DownloadFile;
+                }
+            }
+
+            if (_steps == ESteps.DownloadFile)
+            {
+                // 注意：边玩边下下载器引用计数没有Release
+                if (_downloadFileOp == null)
+                {
+                    DownloadFileOptions options = new DownloadFileOptions(int.MaxValue, 60);
+                    _downloadFileOp = _fileSystem.DownloadFileAsync(_bundle, options);
+                    _downloadFileOp.StartOperation();
+                    AddChildOperation(_downloadFileOp);
+                }
+
+                if (IsWaitForAsyncComplete)
+                    _downloadFileOp.WaitForAsyncComplete();
+
+                _downloadFileOp.UpdateOperation();
+                DownloadProgress = _downloadFileOp.DownloadProgress;
+                DownloadedBytes = _downloadFileOp.DownloadedBytes;
+                if (_downloadFileOp.IsDone == false)
+                    return;
+
+                if (_downloadFileOp.Status == EOperationStatus.Succeed)
+                {
+                    _steps = ESteps.LoadAssetBundle;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = _downloadFileOp.Error;
+                }
+            }
+
+            if (_steps == ESteps.LoadAssetBundle)
+            {
+                if (_bundle.Encrypted)
+                {
+                    if (_fileSystem.DecryptionServices == null)
+                    {
+                        _steps = ESteps.Done;
+                        Status = EOperationStatus.Failed;
+                        Error = $"The {nameof(IDecryptionServices)} is null !";
+                        YooLogger.Error(Error);
+                        return;
+                    }
+                }
+
+                if (IsWaitForAsyncComplete)
+                {
+                    if (_bundle.Encrypted)
+                    {
+                        var decryptResult = _fileSystem.LoadEncryptedAssetBundle(_bundle);
+                        _assetBundle = decryptResult.Result;
+                        _managedStream = decryptResult.ManagedStream;
+                    }
+                    else
+                    {
+                        string filePath = _fileSystem.GetCacheBundleFileLoadPath(_bundle);
+                        _assetBundle = AssetBundle.LoadFromFile(filePath);
+                    }
+                }
+                else
+                {
+                    if (_bundle.Encrypted)
+                    {
+                        var decryptResult = _fileSystem.LoadEncryptedAssetBundleAsync(_bundle);
+                        _createRequest = decryptResult.CreateRequest;
+                        _managedStream = decryptResult.ManagedStream;
+                    }
+                    else
+                    {
+                        string filePath = _fileSystem.GetCacheBundleFileLoadPath(_bundle);
+                        _createRequest = AssetBundle.LoadFromFileAsync(filePath);
+                    }
+                }
+
+                _steps = ESteps.CheckResult;
+            }
+
+            if (_steps == ESteps.CheckResult)
+            {
+                if (_createRequest != null)
+                {
+                    if (IsWaitForAsyncComplete)
+                    {
+                        // 强制挂起主线程（注意：该操作会很耗时）
+                        YooLogger.Warning("Suspend the main thread to load unity bundle.");
+                        _assetBundle = _createRequest.assetBundle;
+                    }
+                    else
+                    {
+                        if (_createRequest.isDone == false)
+                            return;
+                        _assetBundle = _createRequest.assetBundle;
+                    }
+                }
+
+                if (_assetBundle != null)
+                {
+                    _steps = ESteps.Done;
+                    Result = new AssetBundleResult(_fileSystem, _bundle, _assetBundle, _managedStream);
+                    Status = EOperationStatus.Succeed;
+                    return;
+                }
+
+                // 注意：当缓存文件的校验等级为Low的时候，并不能保证缓存文件的完整性。
+                // 说明：在AssetBundle文件加载失败的情况下，我们需要重新验证文件的完整性！
+                EFileVerifyResult verifyResult = _fileSystem.VerifyCacheFile(_bundle);
+                if (verifyResult == EFileVerifyResult.Succeed)
+                {
+                    if (_bundle.Encrypted)
+                    {
+                        _steps = ESteps.Done;
+                        Status = EOperationStatus.Failed;
+                        Error = $"Failed to load encrypted asset bundle file : {_bundle.BundleName}";
+                        YooLogger.Error(Error);
+                        return;
+                    }
+
+                    // 注意：在安卓移动平台，华为和三星真机上有极小概率加载资源包失败。
+                    // 说明：大多数情况在首次安装下载资源到沙盒内，游戏过程中切换到后台再回到游戏内有很大概率触发！
+                    string filePath = _fileSystem.GetCacheBundleFileLoadPath(_bundle);
+                    byte[] fileData = FileUtility.ReadAllBytes(filePath);
+                    if (fileData != null && fileData.Length > 0)
+                    {
+                        _assetBundle = AssetBundle.LoadFromMemory(fileData);
+                        if (_assetBundle == null)
+                        {
+                            _steps = ESteps.Done;
+                            Status = EOperationStatus.Failed;
+                            Error = $"Failed to load asset bundle from memory : {_bundle.BundleName}";
+                            YooLogger.Error(Error);
+                        }
+                        else
+                        {
+                            _steps = ESteps.Done;
+                            Result = new AssetBundleResult(_fileSystem, _bundle, _assetBundle, null);
+                            Status = EOperationStatus.Succeed;
+                        }
+                    }
+                    else
+                    {
+                        _steps = ESteps.Done;
+                        Status = EOperationStatus.Failed;
+                        Error = $"Failed to read asset bundle file bytes : {_bundle.BundleName}";
+                        YooLogger.Error(Error);
+                    }
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    _fileSystem.DeleteCacheBundleFile(_bundle.BundleGUID);
+                    Status = EOperationStatus.Failed;
+                    Error = $"Find corrupted asset bundle file and delete : {_bundle.BundleName}";
+                    YooLogger.Error(Error);
+                }
+            }
+        }
+        internal override void InternalWaitForAsyncComplete()
+        {
+            while (true)
+            {
+                if (ExecuteWhileDone())
+                {
+                    if (_downloadFileOp != null && _downloadFileOp.Status == EOperationStatus.Failed)
+                        YooLogger.Error($"Try load bundle {_bundle.BundleName} from remote !");
+
+                    _steps = ESteps.Done;
+                    break;
+                }
+            }
+        }
+    }
+
+    internal class DCFSLoadRawBundleOperation : FSLoadBundleOperation
+    {
+        protected enum ESteps
+        {
+            None,
+            CheckExist,
+            DownloadFile,
+            LoadCacheRawBundle,
+            Done,
+        }
+
+        protected readonly DefaultCacheFileSystem _fileSystem;
+        protected readonly PackageBundle _bundle;
+        protected FSDownloadFileOperation _downloadFileOp;
+        protected ESteps _steps = ESteps.None;
+
+
+        internal DCFSLoadRawBundleOperation(DefaultCacheFileSystem fileSystem, PackageBundle bundle)
+        {
+            _fileSystem = fileSystem;
+            _bundle = bundle;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.CheckExist;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.CheckExist)
+            {
+                if (_fileSystem.Exists(_bundle))
+                {
+                    // 注意：缓存的原生文件的格式，可能会在业务端根据需求发生变动！
+                    // 注意：这里需要校验文件格式，如果不一致对本地文件进行修正！
+                    string filePath = _fileSystem.GetCacheBundleFileLoadPath(_bundle);
+                    if (File.Exists(filePath) == false)
+                    {
+                        try
+                        {
+                            var recordFileElement = _fileSystem.GetRecordFileElement(_bundle);
+                            File.Move(recordFileElement.DataFilePath, filePath);
+                            _steps = ESteps.LoadCacheRawBundle;
+                        }
+                        catch (Exception e)
+                        {
+                            _steps = ESteps.Done;
+                            Status = EOperationStatus.Failed;
+                            Error = $"Faild rename raw data file : {e.Message}";
+                        }
+                    }
+                    else
+                    {
+                        DownloadProgress = 1f;
+                        DownloadedBytes = _bundle.FileSize;
+                        _steps = ESteps.LoadCacheRawBundle;
+                    }
+                }
+                else
+                {
+                    _steps = ESteps.DownloadFile;
+                }
+            }
+
+            if (_steps == ESteps.DownloadFile)
+            {
+                // 注意：边玩边下下载器引用计数没有Release
+                if (_downloadFileOp == null)
+                {
+                    DownloadFileOptions options = new DownloadFileOptions(int.MaxValue, 60);
+                    _downloadFileOp = _fileSystem.DownloadFileAsync(_bundle, options);
+                    _downloadFileOp.StartOperation();
+                    AddChildOperation(_downloadFileOp);
+                }
+
+                if (IsWaitForAsyncComplete)
+                    _downloadFileOp.WaitForAsyncComplete();
+
+                _downloadFileOp.UpdateOperation();
+                DownloadProgress = _downloadFileOp.DownloadProgress;
+                DownloadedBytes = _downloadFileOp.DownloadedBytes;
+                if (_downloadFileOp.IsDone == false)
+                    return;
+
+                if (_downloadFileOp.Status == EOperationStatus.Succeed)
+                {
+                    _steps = ESteps.LoadCacheRawBundle;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = _downloadFileOp.Error;
+                }
+            }
+
+            if (_steps == ESteps.LoadCacheRawBundle)
+            {
+                string filePath = _fileSystem.GetCacheBundleFileLoadPath(_bundle);
+                if (File.Exists(filePath))
+                {
+                    _steps = ESteps.Done;
+                    Result = new RawBundleResult(_fileSystem, _bundle);
+                    Status = EOperationStatus.Succeed;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = $"Can not found cache raw bundle file : {filePath}";
+                    YooLogger.Error(Error);
+                }
+            }
+        }
+        internal override void InternalWaitForAsyncComplete()
+        {
+            while (true)
+            {
+                if (ExecuteWhileDone())
+                {
+                    //TODO 拷贝本地文件失败也会触发该错误！
+                    if (_downloadFileOp != null && _downloadFileOp.Status == EOperationStatus.Failed)
+                        YooLogger.Error($"Try load bundle {_bundle.BundleName} from remote !");
+
+                    _steps = ESteps.Done;
+                    break;
+                }
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/DCFSLoadBundleOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a653cabf995909d48935a0486db6116f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/DCFSLoadPackageManifestOperation.cs

@@ -0,0 +1,166 @@
+using System.IO;
+
+namespace YooAsset
+{
+    internal class DCFSLoadPackageManifestOperation : FSLoadPackageManifestOperation
+    {
+        private enum ESteps
+        {
+            None,
+            DownloadPackageHash,
+            DownloadPackageManifest,
+            LoadCachePackageHash,
+            LoadCachePackageManifest,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private readonly string _packageVersion;
+        private readonly int _timeout;
+        private DownloadPackageHashOperation _downloadPackageHashOp;
+        private DownloadPackageManifestOperation _downloadPackageManifestOp;
+        private LoadCachePackageHashOperation _loadCachePackageHashOp;
+        private LoadCachePackageManifestOperation _loadCachePackageManifestOp;
+        private ESteps _steps = ESteps.None;
+
+
+        internal DCFSLoadPackageManifestOperation(DefaultCacheFileSystem fileSystem, string packageVersion, int timeout)
+        {
+            _fileSystem = fileSystem;
+            _packageVersion = packageVersion;
+            _timeout = timeout;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.DownloadPackageHash;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.DownloadPackageHash)
+            {
+                if (_downloadPackageHashOp == null)
+                {
+                    _downloadPackageHashOp = new DownloadPackageHashOperation(_fileSystem, _packageVersion, _timeout);
+                    _downloadPackageHashOp.StartOperation();
+                    AddChildOperation(_downloadPackageHashOp);
+                }
+
+                _downloadPackageHashOp.UpdateOperation();
+                if (_downloadPackageHashOp.IsDone == false)
+                    return;
+
+                if (_downloadPackageHashOp.Status == EOperationStatus.Succeed)
+                {
+                    _steps = ESteps.DownloadPackageManifest;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = _downloadPackageHashOp.Error;
+                }
+            }
+
+            if (_steps == ESteps.DownloadPackageManifest)
+            {
+                if (_downloadPackageManifestOp == null)
+                {
+                    _downloadPackageManifestOp = new DownloadPackageManifestOperation(_fileSystem, _packageVersion, _timeout);
+                    _downloadPackageManifestOp.StartOperation();
+                    AddChildOperation(_downloadPackageManifestOp);
+                }
+
+                _downloadPackageManifestOp.UpdateOperation();
+                if (_downloadPackageManifestOp.IsDone == false)
+                    return;
+
+                if (_downloadPackageManifestOp.Status == EOperationStatus.Succeed)
+                {
+                    _steps = ESteps.LoadCachePackageHash;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = _downloadPackageManifestOp.Error;
+                }
+            }
+
+            if (_steps == ESteps.LoadCachePackageHash)
+            {
+                if (_loadCachePackageHashOp == null)
+                {
+                    _loadCachePackageHashOp = new LoadCachePackageHashOperation(_fileSystem, _packageVersion);
+                    _loadCachePackageHashOp.StartOperation();
+                    AddChildOperation(_loadCachePackageHashOp);
+                }
+
+                _loadCachePackageHashOp.UpdateOperation();
+                if (_loadCachePackageHashOp.IsDone == false)
+                    return;
+
+                if (_loadCachePackageHashOp.Status == EOperationStatus.Succeed)
+                {
+                    _steps = ESteps.LoadCachePackageManifest;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = _loadCachePackageHashOp.Error;
+                    ClearCacheFatalFile();
+                }
+            }
+
+            if (_steps == ESteps.LoadCachePackageManifest)
+            {
+                if (_loadCachePackageManifestOp == null)
+                {
+                    string packageHash = _loadCachePackageHashOp.PackageHash;
+                    _loadCachePackageManifestOp = new LoadCachePackageManifestOperation(_fileSystem, _packageVersion, packageHash);
+                    _loadCachePackageManifestOp.StartOperation();
+                    AddChildOperation(_loadCachePackageManifestOp);
+                }
+
+                _loadCachePackageManifestOp.UpdateOperation();
+                Progress = _loadCachePackageManifestOp.Progress;
+                if (_loadCachePackageManifestOp.IsDone == false)
+                    return;
+
+                if (_loadCachePackageManifestOp.Status == EOperationStatus.Succeed)
+                {
+                    _steps = ESteps.Done;
+                    Manifest = _loadCachePackageManifestOp.Manifest;
+                    Status = EOperationStatus.Succeed;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = _loadCachePackageManifestOp.Error;
+                    ClearCacheFatalFile();
+                }
+            }
+        }
+
+        private void ClearCacheFatalFile()
+        {
+            // 注意：如果加载沙盒内的清单报错，为了避免流程被卡住，主动把损坏的文件删除。
+            string manifestFilePath = _fileSystem.GetCachePackageManifestFilePath(_packageVersion);
+            if (File.Exists(manifestFilePath))
+            {
+                YooLogger.Warning($"Invalid cache manifest file have been removed : {manifestFilePath}");
+                File.Delete(manifestFilePath);
+            }
+
+            string hashFilePath = _fileSystem.GetCachePackageHashFilePath(_packageVersion);
+            if (File.Exists(hashFilePath))
+            {
+                File.Delete(hashFilePath);
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/DCFSLoadPackageManifestOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2447826454481704ab785153ae89be3a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/DCFSRequestPackageVersionOperation.cs

@@ -0,0 +1,64 @@
+
+namespace YooAsset
+{
+    internal class DCFSRequestPackageVersionOperation : FSRequestPackageVersionOperation
+    {
+        private enum ESteps
+        {
+            None,
+            GetPackageVersion,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private readonly bool _appendTimeTicks;
+        private readonly int _timeout;
+        private RequestRemotePackageVersionOperation _requestRemotePackageVersionOp;
+        private ESteps _steps = ESteps.None;
+
+
+        internal DCFSRequestPackageVersionOperation(DefaultCacheFileSystem fileSystem, bool appendTimeTicks, int timeout)
+        {
+            _fileSystem = fileSystem;
+            _appendTimeTicks = appendTimeTicks;
+            _timeout = timeout;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.GetPackageVersion;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.GetPackageVersion)
+            {
+                if (_requestRemotePackageVersionOp == null)
+                {
+                    _requestRemotePackageVersionOp = new RequestRemotePackageVersionOperation(_fileSystem, _appendTimeTicks, _timeout);
+                    _requestRemotePackageVersionOp.StartOperation();
+                    AddChildOperation(_requestRemotePackageVersionOp);
+                }
+
+                _requestRemotePackageVersionOp.UpdateOperation();
+                Progress = _requestRemotePackageVersionOp.Progress;
+                if (_requestRemotePackageVersionOp.IsDone == false)
+                    return;
+
+                if (_requestRemotePackageVersionOp.Status == EOperationStatus.Succeed)
+                {
+                    _steps = ESteps.Done;
+                    PackageVersion = _requestRemotePackageVersionOp.PackageVersion;
+                    Status = EOperationStatus.Succeed;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = _requestRemotePackageVersionOp.Error;
+                }
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/DCFSRequestPackageVersionOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 856b1334d67ed4d41b31a583f713c449
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3414bfb159816a74f917270b7d48c25f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/ClearAllCacheBundleFilesOperation.cs

@@ -0,0 +1,67 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset
+{
+    internal sealed class ClearAllCacheBundleFilesOperation : FSClearCacheFilesOperation
+    {
+        private enum ESteps
+        {
+            None,
+            GetAllCacheFiles,
+            ClearAllCacheFiles,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private List<string> _allBundleGUIDs;
+        private int _fileTotalCount = 0;
+        private ESteps _steps = ESteps.None;
+
+
+        internal ClearAllCacheBundleFilesOperation(DefaultCacheFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.GetAllCacheFiles;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.GetAllCacheFiles)
+            {
+                _allBundleGUIDs = _fileSystem.GetAllCachedBundleGUIDs();
+                _fileTotalCount = _allBundleGUIDs.Count;
+                _steps = ESteps.ClearAllCacheFiles;
+                YooLogger.Log($"Found all cache files count : {_fileTotalCount}");
+            }
+
+            if (_steps == ESteps.ClearAllCacheFiles)
+            {
+                for (int i = _allBundleGUIDs.Count - 1; i >= 0; i--)
+                {
+                    string bundleGUID = _allBundleGUIDs[i];
+                    _fileSystem.DeleteCacheBundleFile(bundleGUID);
+                    _allBundleGUIDs.RemoveAt(i);
+                    if (OperationSystem.IsBusy)
+                        break;
+                }
+
+                if (_fileTotalCount == 0)
+                    Progress = 1.0f;
+                else
+                    Progress = 1.0f - (_allBundleGUIDs.Count / _fileTotalCount);
+
+                if (_allBundleGUIDs.Count == 0)
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/ClearAllCacheBundleFilesOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: daed187502431d347bf11bddcf8d77de
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/ClearAllCacheManifestFilesOperation.cs

@@ -0,0 +1,63 @@
+using System;
+using System.IO;
+
+namespace YooAsset
+{
+    internal sealed class ClearAllCacheManifestFilesOperation : FSClearCacheFilesOperation
+    {
+        private enum ESteps
+        {
+            None,
+            ClearAllCacheFiles,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private ESteps _steps = ESteps.None;
+
+
+        internal ClearAllCacheManifestFilesOperation(DefaultCacheFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.ClearAllCacheFiles;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.ClearAllCacheFiles)
+            {
+                try
+                {
+                    // 注意：如果正在下载资源清单，会有几率触发异常！
+                    string directoryRoot = _fileSystem.GetCacheManifestFilesRoot();
+                    DirectoryInfo directoryInfo = new DirectoryInfo(directoryRoot);
+                    if (directoryInfo.Exists)
+                    {
+                        foreach (FileInfo fileInfo in directoryInfo.GetFiles())
+                        {
+                            string fileName = fileInfo.Name;
+                            if (fileName == DefaultCacheFileSystemDefine.AppFootPrintFileName)
+                                continue;
+
+                            fileInfo.Delete();
+                        }
+                    }
+
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+                catch (Exception ex)
+                {
+                    _steps = ESteps.Done;
+                    Error = ex.Message;
+                    Status = EOperationStatus.Failed;
+                }
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/ClearAllCacheManifestFilesOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5643382e7031ba14cbb4ab0f4a9acd94
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/ClearCacheBundleFilesByTagsOperaiton.cs

@@ -0,0 +1,135 @@
+using System.Collections.Generic;
+
+namespace YooAsset
+{
+    internal class ClearCacheBundleFilesByTagsOperaiton : FSClearCacheFilesOperation
+    {
+        private enum ESteps
+        {
+            None,
+            CheckManifest,
+            CheckArgs,
+            GetClearCacheFiles,
+            ClearFilterCacheFiles,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private readonly PackageManifest _manifest;
+        private readonly object _clearParam;
+        private string[] _tags;
+        private List<string> _clearBundleGUIDs;
+        private int _clearFileTotalCount = 0;
+        private ESteps _steps = ESteps.None;
+
+        internal ClearCacheBundleFilesByTagsOperaiton(DefaultCacheFileSystem fileSystem, PackageManifest manifest, object clearParam)
+        {
+            _fileSystem = fileSystem;
+            _manifest = manifest;
+            _clearParam = clearParam;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.CheckManifest;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.CheckManifest)
+            {
+                if (_manifest == null)
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = "Can not found active package manifest !";
+                }
+                else
+                {
+                    _steps = ESteps.CheckArgs;
+                }
+            }
+
+            if (_steps == ESteps.CheckArgs)
+            {
+                if (_clearParam == null)
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = "Clear param is null !";
+                    return;
+                }
+
+                if (_clearParam is string)
+                {
+                    _tags = new string[] { _clearParam as string };
+                }
+                else if (_clearParam is List<string>)
+                {
+                    var tempList = _clearParam as List<string>;
+                    _tags = tempList.ToArray();
+                }
+                else if (_clearParam is string[])
+                {
+                    _tags = _clearParam as string[];
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = $"Invalid clear param : {_clearParam.GetType().FullName}";
+                    return;
+                }
+
+                _steps = ESteps.GetClearCacheFiles;
+            }
+
+            if (_steps == ESteps.GetClearCacheFiles)
+            {
+                _clearBundleGUIDs = GetBundleGUIDsByTag();
+                _clearFileTotalCount = _clearBundleGUIDs.Count;
+                _steps = ESteps.ClearFilterCacheFiles;
+            }
+
+            if (_steps == ESteps.ClearFilterCacheFiles)
+            {
+                for (int i = _clearBundleGUIDs.Count - 1; i >= 0; i--)
+                {
+                    string bundleGUID = _clearBundleGUIDs[i];
+                    _fileSystem.DeleteCacheBundleFile(bundleGUID);
+                    _clearBundleGUIDs.RemoveAt(i);
+                    if (OperationSystem.IsBusy)
+                        break;
+                }
+
+                if (_clearFileTotalCount == 0)
+                    Progress = 1.0f;
+                else
+                    Progress = 1.0f - (_clearBundleGUIDs.Count / _clearFileTotalCount);
+
+                if (_clearBundleGUIDs.Count == 0)
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+            }
+        }
+        private List<string> GetBundleGUIDsByTag()
+        {
+            var allBundleGUIDs = _fileSystem.GetAllCachedBundleGUIDs();
+            List<string> result = new List<string>(allBundleGUIDs.Count);
+            foreach (var bundleGUID in allBundleGUIDs)
+            {
+                if (_manifest.TryGetPackageBundleByBundleGUID(bundleGUID, out PackageBundle bundle))
+                {
+                    if (bundle.HasTag(_tags))
+                    {
+                        result.Add(bundleGUID);
+                    }
+                }
+            }
+            return result;
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/ClearCacheBundleFilesByTagsOperaiton.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c42345c14a903274fb160a813ee174dc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/ClearUnusedCacheBundleFilesOperation.cs

@@ -0,0 +1,98 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset
+{
+    internal sealed class ClearUnusedCacheBundleFilesOperation : FSClearCacheFilesOperation
+    {
+        private enum ESteps
+        {
+            None,
+            CheckManifest,
+            GetUnusedCacheFiles,
+            ClearUnusedCacheFiles,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private readonly PackageManifest _manifest;
+        private List<string> _unusedBundleGUIDs;
+        private int _unusedFileTotalCount = 0;
+        private ESteps _steps = ESteps.None;
+
+
+        internal ClearUnusedCacheBundleFilesOperation(DefaultCacheFileSystem fileSystem, PackageManifest manifest)
+        {
+            _fileSystem = fileSystem;
+            _manifest = manifest;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.CheckManifest;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.CheckManifest)
+            {
+                if (_manifest == null)
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = "Can not found active package manifest !";
+                }
+                else
+                {
+                    _steps = ESteps.GetUnusedCacheFiles;
+                }
+            }
+
+            if (_steps == ESteps.GetUnusedCacheFiles)
+            {
+                _unusedBundleGUIDs = GetUnusedBundleGUIDs();
+                _unusedFileTotalCount = _unusedBundleGUIDs.Count;
+                _steps = ESteps.ClearUnusedCacheFiles;
+                YooLogger.Log($"Found unused cache files count : {_unusedFileTotalCount}");
+            }
+
+            if (_steps == ESteps.ClearUnusedCacheFiles)
+            {
+                for (int i = _unusedBundleGUIDs.Count - 1; i >= 0; i--)
+                {
+                    string bundleGUID = _unusedBundleGUIDs[i];
+                    _fileSystem.DeleteCacheBundleFile(bundleGUID);
+                    _unusedBundleGUIDs.RemoveAt(i);
+                    if (OperationSystem.IsBusy)
+                        break;
+                }
+
+                if (_unusedFileTotalCount == 0)
+                    Progress = 1.0f;
+                else
+                    Progress = 1.0f - (_unusedBundleGUIDs.Count / _unusedFileTotalCount);
+
+                if (_unusedBundleGUIDs.Count == 0)
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+            }
+        }
+
+        private List<string> GetUnusedBundleGUIDs()
+        {
+            var allBundleGUIDs = _fileSystem.GetAllCachedBundleGUIDs();
+            List<string> result = new List<string>(allBundleGUIDs.Count);
+            foreach (var bundleGUID in allBundleGUIDs)
+            {
+                if (_manifest.IsIncludeBundleFile(bundleGUID) == false)
+                {
+                    result.Add(bundleGUID);
+                }
+            }
+            return result;
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/ClearUnusedCacheBundleFilesOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: be7b242f10abf524fa59e9ca0d12b052
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/ClearUnusedCacheManifestFilesOperation.cs

@@ -0,0 +1,85 @@
+using System;
+using System.IO;
+
+namespace YooAsset
+{
+    internal sealed class ClearUnusedCacheManifestFilesOperation : FSClearCacheFilesOperation
+    {
+        private enum ESteps
+        {
+            None,
+            CheckManifest,
+            ClearUnusedCacheFiles,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private readonly PackageManifest _manifest;
+        private ESteps _steps = ESteps.None;
+
+
+        internal ClearUnusedCacheManifestFilesOperation(DefaultCacheFileSystem fileSystem, PackageManifest manifest)
+        {
+            _fileSystem = fileSystem;
+            _manifest = manifest;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.CheckManifest;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.CheckManifest)
+            {
+                if (_manifest == null)
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = "Can not found active package manifest !";
+                }
+                else
+                {
+                    _steps = ESteps.ClearUnusedCacheFiles;
+                }
+            }
+
+            if (_steps == ESteps.ClearUnusedCacheFiles)
+            {
+                try
+                {
+                    string activeManifestFileName = YooAssetSettingsData.GetManifestBinaryFileName(_manifest.PackageName, _manifest.PackageVersion);
+                    string activeHashFileName = YooAssetSettingsData.GetPackageHashFileName(_manifest.PackageName, _manifest.PackageVersion);
+
+                    // 注意：如果正在下载资源清单，会有几率触发异常！
+                    string directoryRoot = _fileSystem.GetCacheManifestFilesRoot();
+                    DirectoryInfo directoryInfo = new DirectoryInfo(directoryRoot);
+                    if (directoryInfo.Exists)
+                    {
+                        foreach (FileInfo fileInfo in directoryInfo.GetFiles())
+                        {
+                            string fileName = fileInfo.Name;
+                            if (fileName == DefaultCacheFileSystemDefine.AppFootPrintFileName)
+                                continue;
+                            if (fileName == activeManifestFileName || fileName == activeHashFileName)
+                                continue;
+
+                            fileInfo.Delete();
+                        }
+                    }
+
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+                catch (Exception ex)
+                {
+                    _steps = ESteps.Done;
+                    Error = ex.Message;
+                    Status = EOperationStatus.Failed;
+                }
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/ClearUnusedCacheManifestFilesOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d911513cf97d862448df570f0c8e9b38
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadCenterOperation.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+
+namespace YooAsset
+{
+    internal class DownloadCenterOperation : AsyncOperationBase
+    {
+        private readonly DefaultCacheFileSystem _fileSystem;
+        protected readonly Dictionary<string, DefaultDownloadFileOperation> _downloaders = new Dictionary<string, DefaultDownloadFileOperation>(1000);
+        protected readonly List<string> _removeDownloadList = new List<string>(1000);
+
+        public DownloadCenterOperation(DefaultCacheFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+        }
+        internal override void InternalStart()
+        {
+        }
+        internal override void InternalUpdate()
+        {
+            // 获取可移除的下载器集合
+            _removeDownloadList.Clear();
+            foreach (var valuePair in _downloaders)
+            {
+                var downloader = valuePair.Value;
+                downloader.UpdateOperation();
+
+                // 注意：主动终止引用计数为零的下载任务
+                if (downloader.RefCount <= 0)
+                {
+                    _removeDownloadList.Add(valuePair.Key);
+                    downloader.AbortOperation();
+                    continue;
+                }
+
+                if (downloader.IsDone)
+                {
+                    _removeDownloadList.Add(valuePair.Key);
+                    continue;
+                }
+            }
+
+            // 移除下载器
+            foreach (var key in _removeDownloadList)
+            {
+                _downloaders.Remove(key);
+            }
+
+            // 最大并发数检测
+            int processCount = GetProcessingOperationCount();
+            if (processCount != _downloaders.Count)
+            {
+                if (processCount < _fileSystem.DownloadMaxConcurrency)
+                {
+                    int startCount = _fileSystem.DownloadMaxConcurrency - processCount;
+                    if (startCount > _fileSystem.DownloadMaxRequestPerFrame)
+                        startCount = _fileSystem.DownloadMaxRequestPerFrame;
+
+                    foreach (var operationPair in _downloaders)
+                    {
+                        var operation = operationPair.Value;
+                        if (operation.Status == EOperationStatus.None)
+                        {
+                            operation.StartOperation();
+                            startCount--;
+                            if (startCount <= 0)
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// 创建下载任务
+        /// </summary>
+        public FSDownloadFileOperation DownloadFileAsync(PackageBundle bundle, DownloadFileOptions options)
+        {
+            // 查询旧的下载器
+            if (_downloaders.TryGetValue(bundle.BundleGUID, out var oldDownloader))
+            {
+                return oldDownloader;
+            }
+
+            // 设置请求URL
+            if (string.IsNullOrEmpty(options.ImportFilePath))
+            {
+                options.MainURL = _fileSystem.RemoteServices.GetRemoteMainURL(bundle.FileName);
+                options.FallbackURL = _fileSystem.RemoteServices.GetRemoteFallbackURL(bundle.FileName);
+            }
+            else
+            {
+                // 注意：把本地文件路径指定为远端下载地址
+                options.MainURL = DownloadSystemHelper.ConvertToWWWPath(options.ImportFilePath);
+                options.FallbackURL = options.MainURL;
+            }
+
+            // 创建新的下载器
+            DefaultDownloadFileOperation newDownloader;
+            if (bundle.FileSize >= _fileSystem.ResumeDownloadMinimumSize)
+            {
+                newDownloader = new DownloadResumeFileOperation(_fileSystem, bundle, options);
+                AddChildOperation(newDownloader);
+                _downloaders.Add(bundle.BundleGUID, newDownloader);
+            }
+            else
+            {
+                newDownloader = new DownloadNormalFileOperation(_fileSystem, bundle, options);
+                AddChildOperation(newDownloader);
+                _downloaders.Add(bundle.BundleGUID, newDownloader);
+            }
+            return newDownloader;
+        }
+
+        /// <summary>
+        /// 获取正在进行中的下载器总数
+        /// </summary>
+        private int GetProcessingOperationCount()
+        {
+            int count = 0;
+            foreach (var operationPair in _downloaders)
+            {
+                var operation = operationPair.Value;
+                if (operation.Status != EOperationStatus.None)
+                    count++;
+            }
+            return count;
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadCenterOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 768ef2df3433df245a26fec28d022e45
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadHandlerFileRange.cs

@@ -0,0 +1,87 @@
+using System;
+using System.IO;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace YooAsset
+{
+    /// <summary>
+    /// 支持Unity2018版本的断点续传下载器
+    /// </summary>
+    internal class DownloadHandlerFileRange : DownloadHandlerScript
+    {
+        private string _fileSavePath;
+        private long _fileTotalSize;
+        private UnityWebRequest _webRequest;
+        private FileStream _fileStream;
+
+        private long _localFileSize = 0;
+        private long _curFileSize = 0;
+
+
+        public DownloadHandlerFileRange(string fileSavePath, long fileTotalSize, UnityWebRequest webRequest) : base(new byte[1024 * 1024])
+        {
+            _fileSavePath = fileSavePath;
+            _fileTotalSize = fileTotalSize;
+            _webRequest = webRequest;
+
+            if (File.Exists(fileSavePath))
+            {
+                FileInfo fileInfo = new FileInfo(fileSavePath);
+                _localFileSize = fileInfo.Length;
+            }
+
+            _fileStream = new FileStream(_fileSavePath, FileMode.Append, FileAccess.Write);
+            _curFileSize = _localFileSize;
+        }
+        protected override bool ReceiveData(byte[] data, int dataLength)
+        {
+            if (data == null || dataLength == 0 || _webRequest.responseCode >= 400)
+                return false;
+
+            if (_fileStream == null)
+                return false;
+
+            _fileStream.Write(data, 0, dataLength);
+            _curFileSize += dataLength;
+            return true;
+        }
+
+        /// <summary>
+        /// UnityWebRequest.downloadHandler.data
+        /// </summary>
+        protected override byte[] GetData()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// UnityWebRequest.downloadHandler.text
+        /// </summary>
+        protected override string GetText()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// UnityWebRequest.downloadProgress
+        /// </summary>
+        protected override float GetProgress()
+        {
+            return _fileTotalSize == 0 ? 0 : ((float)_curFileSize) / _fileTotalSize;
+        }
+
+        /// <summary>
+        /// 释放下载句柄
+        /// </summary>
+        public void Cleanup()
+        {
+            if (_fileStream != null)
+            {
+                _fileStream.Flush();
+                _fileStream.Dispose();
+                _fileStream = null;
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadHandlerFileRange.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 94254ab8e4496214884c11a891c131c6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadNormalFileOperation.cs

@@ -0,0 +1,208 @@
+using System.IO;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace YooAsset
+{
+    internal sealed class DownloadNormalFileOperation : DefaultDownloadFileOperation
+    {
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private VerifyTempFileOperation _verifyOperation;
+        private bool _isReuqestLocalFile;
+        private string _tempFilePath;
+        private ESteps _steps = ESteps.None;
+
+        internal DownloadNormalFileOperation(DefaultCacheFileSystem fileSystem, PackageBundle bundle, DownloadFileOptions options) : base(bundle, options)
+        {
+            _fileSystem = fileSystem;
+        }
+        internal override void InternalStart()
+        {
+            _isReuqestLocalFile = DownloadSystemHelper.IsRequestLocalFile(Options.MainURL);
+            _tempFilePath = _fileSystem.GetTempFilePath(Bundle);
+            _steps = ESteps.CheckExists;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            // 检测文件是否存在
+            if (_steps == ESteps.CheckExists)
+            {
+                if (_fileSystem.Exists(Bundle))
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+                else
+                {
+                    _steps = ESteps.CreateRequest;
+                }
+            }
+
+            // 创建下载器
+            if (_steps == ESteps.CreateRequest)
+            {
+                FileUtility.CreateFileDirectory(_tempFilePath);
+
+                // 删除临时文件
+                if (File.Exists(_tempFilePath))
+                    File.Delete(_tempFilePath);
+
+                // 获取请求地址
+                _requestURL = GetRequestURL();
+
+                // 重置请求
+                ResetRequestFiled();
+
+                // 创建下载器
+                CreateWebRequest();
+
+                _steps = ESteps.CheckRequest;
+            }
+
+            // 检测下载结果
+            if (_steps == ESteps.CheckRequest)
+            {
+                DownloadProgress = _webRequest.downloadProgress;
+                DownloadedBytes = (long)_webRequest.downloadedBytes;
+                Progress = DownloadProgress;
+                if (_webRequest.isDone == false)
+                {
+                    CheckRequestTimeout();
+                    return;
+                }
+
+                // 检查网络错误
+                if (CheckRequestResult())
+                    _steps = ESteps.VerifyTempFile;
+                else
+                    _steps = ESteps.TryAgain;
+
+                // 注意：最终释放请求器
+                DisposeWebRequest();
+            }
+
+            // 验证下载文件
+            if (_steps == ESteps.VerifyTempFile)
+            {
+                var element = new TempFileElement(_tempFilePath, Bundle.FileCRC, Bundle.FileSize);
+                _verifyOperation = new VerifyTempFileOperation(element);
+                _verifyOperation.StartOperation();
+                AddChildOperation(_verifyOperation);
+                _steps = ESteps.CheckVerifyTempFile;
+            }
+
+            // 等待验证完成
+            if (_steps == ESteps.CheckVerifyTempFile)
+            {
+                if (IsWaitForAsyncComplete)
+                    _verifyOperation.WaitForAsyncComplete();
+
+                _verifyOperation.UpdateOperation();
+                if (_verifyOperation.IsDone == false)
+                    return;
+
+                if (_verifyOperation.Status == EOperationStatus.Succeed)
+                {
+                    if (_fileSystem.WriteCacheBundleFile(Bundle, _tempFilePath))
+                    {
+                        _steps = ESteps.Done;
+                        Status = EOperationStatus.Succeed;
+                    }
+                    else
+                    {
+                        _steps = ESteps.Done;
+                        Status = EOperationStatus.Failed;
+                        Error = $"{_fileSystem.GetType().FullName} failed to write file !";
+                        YooLogger.Error(Error);
+                    }
+                }
+                else
+                {
+                    _steps = ESteps.TryAgain;
+                    Error = _verifyOperation.Error;
+                }
+
+                // 注意：验证完成后直接删除文件
+                if (File.Exists(_tempFilePath))
+                    File.Delete(_tempFilePath);
+            }
+
+            // 重新尝试下载
+            if (_steps == ESteps.TryAgain)
+            {
+                //TODO 拷贝本地文件失败后不再尝试！
+                if (_isReuqestLocalFile)
+                {
+                    Status = EOperationStatus.Failed;
+                    _steps = ESteps.Done;
+                    YooLogger.Error(Error);
+                    return;
+                }
+
+                if (FailedTryAgain <= 0)
+                {
+                    Status = EOperationStatus.Failed;
+                    _steps = ESteps.Done;
+                    YooLogger.Error(Error);
+                    return;
+                }
+
+                _tryAgainTimer += Time.unscaledDeltaTime;
+                if (_tryAgainTimer > 1f)
+                {
+                    FailedTryAgain--;
+                    _steps = ESteps.CreateRequest;
+                    YooLogger.Warning(Error);
+                }
+            }
+        }
+        internal override void InternalAbort()
+        {
+            _steps = ESteps.Done;
+            DisposeWebRequest();
+        }
+        internal override void InternalWaitForAsyncComplete()
+        {
+            while (true)
+            {
+                //TODO 如果是导入或解压本地文件，执行等待完毕
+                if (_isReuqestLocalFile)
+                {
+                    InternalUpdate();
+                    if (IsDone)
+                        break;
+                }
+                else
+                {
+                    if (ExecuteWhileDone())
+                    {
+                        _steps = ESteps.Done;
+                        break;
+                    }
+                }
+            }
+        }
+
+        private void CreateWebRequest()
+        {
+            _webRequest = DownloadSystemHelper.NewUnityWebRequestGet(_requestURL);
+            DownloadHandlerFile handler = new DownloadHandlerFile(_tempFilePath);
+            handler.removeFileOnAbort = true;
+            _webRequest.downloadHandler = handler;
+            _webRequest.disposeDownloadHandlerOnDispose = true;
+            _webRequest.SendWebRequest();
+        }
+        private void DisposeWebRequest()
+        {
+            if (_webRequest != null)
+            {
+                //注意：引擎底层会自动调用Abort方法
+                _webRequest.Dispose();
+                _webRequest = null;
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadNormalFileOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 759967d543776a0469b625eff171d235
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadPackageHashOperation.cs

@@ -0,0 +1,93 @@
+using System.IO;
+
+namespace YooAsset
+{
+    internal class DownloadPackageHashOperation : AsyncOperationBase
+    {
+        private enum ESteps
+        {
+            None,
+            CheckExist,
+            DownloadFile,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private readonly string _packageVersion;
+        private readonly int _timeout;
+        private UnityWebFileRequestOperation _webFileRequestOp;
+        private int _requestCount = 0;
+        private ESteps _steps = ESteps.None;
+
+
+        internal DownloadPackageHashOperation(DefaultCacheFileSystem fileSystem, string packageVersion, int timeout)
+        {
+            _fileSystem = fileSystem;
+            _packageVersion = packageVersion;
+            _timeout = timeout;
+        }
+        internal override void InternalStart()
+        {
+            _requestCount = WebRequestCounter.GetRequestFailedCount(_fileSystem.PackageName, nameof(DownloadPackageHashOperation));
+            _steps = ESteps.CheckExist;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.CheckExist)
+            {
+                string filePath = _fileSystem.GetCachePackageHashFilePath(_packageVersion);
+                if (File.Exists(filePath))
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+                else
+                {
+                    _steps = ESteps.DownloadFile;
+                }
+            }
+
+            if (_steps == ESteps.DownloadFile)
+            {
+                if (_webFileRequestOp == null)
+                {
+                    string savePath = _fileSystem.GetCachePackageHashFilePath(_packageVersion);
+                    string fileName = YooAssetSettingsData.GetPackageHashFileName(_fileSystem.PackageName, _packageVersion);
+                    string webURL = GetWebRequestURL(fileName);
+                    _webFileRequestOp = new UnityWebFileRequestOperation(webURL, savePath, _timeout);
+                    _webFileRequestOp.StartOperation();
+                    AddChildOperation(_webFileRequestOp);
+                }
+
+                _webFileRequestOp.UpdateOperation();
+                if (_webFileRequestOp.IsDone == false)
+                    return;
+
+                if (_webFileRequestOp.Status == EOperationStatus.Succeed)
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = _webFileRequestOp.Error;
+                    WebRequestCounter.RecordRequestFailed(_fileSystem.PackageName, nameof(DownloadPackageHashOperation));
+                }
+            }
+        }
+
+        private string GetWebRequestURL(string fileName)
+        {
+            // 轮流返回请求地址
+            if (_requestCount % 2 == 0)
+                return _fileSystem.RemoteServices.GetRemoteMainURL(fileName);
+            else
+                return _fileSystem.RemoteServices.GetRemoteFallbackURL(fileName);
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadPackageHashOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8604af2bf2c8a1d4684cb59d81ab9445
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadPackageManifestOperation.cs

@@ -0,0 +1,93 @@
+using System.IO;
+
+namespace YooAsset
+{
+    internal class DownloadPackageManifestOperation : AsyncOperationBase
+    {
+        private enum ESteps
+        {
+            None,
+            CheckExist,
+            DownloadFile,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private readonly string _packageVersion;
+        private readonly int _timeout;
+        private UnityWebFileRequestOperation _webFileRequestOp;
+        private int _requestCount = 0;
+        private ESteps _steps = ESteps.None;
+
+
+        internal DownloadPackageManifestOperation(DefaultCacheFileSystem fileSystem, string packageVersion, int timeout)
+        {
+            _fileSystem = fileSystem;
+            _packageVersion = packageVersion;
+            _timeout = timeout;
+        }
+        internal override void InternalStart()
+        {
+            _requestCount = WebRequestCounter.GetRequestFailedCount(_fileSystem.PackageName, nameof(DownloadPackageManifestOperation));
+            _steps = ESteps.CheckExist;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.CheckExist)
+            {
+                string filePath = _fileSystem.GetCachePackageManifestFilePath(_packageVersion);
+                if (File.Exists(filePath))
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+                else
+                {
+                    _steps = ESteps.DownloadFile;
+                }
+            }
+
+            if (_steps == ESteps.DownloadFile)
+            {
+                if (_webFileRequestOp == null)
+                {
+                    string savePath = _fileSystem.GetCachePackageManifestFilePath(_packageVersion);
+                    string fileName = YooAssetSettingsData.GetManifestBinaryFileName(_fileSystem.PackageName, _packageVersion);
+                    string webURL = GetDownloadRequestURL(fileName);
+                    _webFileRequestOp = new UnityWebFileRequestOperation(webURL, savePath, _timeout);
+                    _webFileRequestOp.StartOperation();
+                    AddChildOperation(_webFileRequestOp);
+                }
+
+                _webFileRequestOp.UpdateOperation();
+                if (_webFileRequestOp.IsDone == false)
+                    return;
+
+                if (_webFileRequestOp.Status == EOperationStatus.Succeed)
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = _webFileRequestOp.Error;
+                    WebRequestCounter.RecordRequestFailed(_fileSystem.PackageName, nameof(DownloadPackageManifestOperation));
+                }
+            }
+        }
+
+        private string GetDownloadRequestURL(string fileName)
+        {
+            // 轮流返回请求地址
+            if (_requestCount % 2 == 0)
+                return _fileSystem.RemoteServices.GetRemoteMainURL(fileName);
+            else
+                return _fileSystem.RemoteServices.GetRemoteFallbackURL(fileName);
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadPackageManifestOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9d5983f1b32b2e14c8b4c5b539bee8fa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadResumeFileOperation.cs

@@ -0,0 +1,252 @@
+using System.IO;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace YooAsset
+{
+    internal sealed class DownloadResumeFileOperation : DefaultDownloadFileOperation
+    {
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private DownloadHandlerFileRange _downloadHandle;
+        private VerifyTempFileOperation _verifyOperation;
+        private bool _isReuqestLocalFile;
+        private long _fileOriginLength = 0;
+        private string _tempFilePath;
+        private ESteps _steps = ESteps.None;
+
+
+        internal DownloadResumeFileOperation(DefaultCacheFileSystem fileSystem, PackageBundle bundle, DownloadFileOptions options) : base(bundle, options)
+        {
+            _fileSystem = fileSystem;
+        }
+        internal override void InternalStart()
+        {
+            _isReuqestLocalFile = DownloadSystemHelper.IsRequestLocalFile(Options.MainURL);
+            _tempFilePath = _fileSystem.GetTempFilePath(Bundle);
+            _steps = ESteps.CheckExists;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            // 检测文件是否存在
+            if (_steps == ESteps.CheckExists)
+            {
+                if (_fileSystem.Exists(Bundle))
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+                else
+                {
+                    _steps = ESteps.CreateRequest;
+                }
+            }
+
+            // 创建下载器
+            if (_steps == ESteps.CreateRequest)
+            {
+                FileUtility.CreateFileDirectory(_tempFilePath);
+
+                // 获取请求地址
+                _requestURL = GetRequestURL();
+
+                // 重置变量
+                ResetRequestFiled();
+
+                // 获取下载起始位置
+                _fileOriginLength = 0;
+                long fileBeginLength = -1;
+                if (File.Exists(_tempFilePath))
+                {
+                    FileInfo fileInfo = new FileInfo(_tempFilePath);
+                    if (fileInfo.Length >= Bundle.FileSize)
+                    {
+                        // 删除临时文件
+                        File.Delete(_tempFilePath);
+                    }
+                    else
+                    {
+                        fileBeginLength = fileInfo.Length;
+                        _fileOriginLength = fileBeginLength;
+                        DownloadedBytes = _fileOriginLength;
+                    }
+                }
+
+                // 创建下载器
+                CreateWebRequest(fileBeginLength);
+
+                _steps = ESteps.CheckRequest;
+            }
+
+            // 检测下载结果
+            if (_steps == ESteps.CheckRequest)
+            {
+                DownloadProgress = _webRequest.downloadProgress;
+                DownloadedBytes = _fileOriginLength + (long)_webRequest.downloadedBytes;
+                if (_webRequest.isDone == false)
+                {
+                    CheckRequestTimeout();
+                    return;
+                }
+
+                // 检查网络错误
+                if (CheckRequestResult())
+                    _steps = ESteps.VerifyTempFile;
+                else
+                    _steps = ESteps.TryAgain;
+
+                // 在遇到特殊错误的时候删除文件
+                ClearTempFileWhenError();
+
+                // 注意：最终释放请求器
+                DisposeWebRequest();
+            }
+
+            // 验证下载文件
+            if (_steps == ESteps.VerifyTempFile)
+            {
+                var element = new TempFileElement(_tempFilePath, Bundle.FileCRC, Bundle.FileSize);
+                _verifyOperation = new VerifyTempFileOperation(element);
+                _verifyOperation.StartOperation();
+                AddChildOperation(_verifyOperation);
+                _steps = ESteps.CheckVerifyTempFile;
+            }
+
+            // 等待验证完成
+            if (_steps == ESteps.CheckVerifyTempFile)
+            {
+                if (IsWaitForAsyncComplete)
+                    _verifyOperation.WaitForAsyncComplete();
+
+                _verifyOperation.UpdateOperation();
+                if (_verifyOperation.IsDone == false)
+                    return;
+
+                if (_verifyOperation.Status == EOperationStatus.Succeed)
+                {
+                    if (_fileSystem.WriteCacheBundleFile(Bundle, _tempFilePath))
+                    {
+                        Status = EOperationStatus.Succeed;
+                        _steps = ESteps.Done;
+                    }
+                    else
+                    {
+                        Error = $"{_fileSystem.GetType().FullName} failed to write file !";
+                        Status = EOperationStatus.Failed;
+                        _steps = ESteps.Done;
+                    }
+                }
+                else
+                {
+                    Error = _verifyOperation.Error;
+                    _steps = ESteps.TryAgain;
+                }
+
+                // 注意：验证完成后直接删除文件
+                if (File.Exists(_tempFilePath))
+                    File.Delete(_tempFilePath);
+            }
+
+            // 重新尝试下载
+            if (_steps == ESteps.TryAgain)
+            {
+                //TODO 拷贝本地文件失败后不再尝试！
+                if (_isReuqestLocalFile)
+                {
+                    Status = EOperationStatus.Failed;
+                    _steps = ESteps.Done;
+                    YooLogger.Error(Error);
+                    return;
+                }
+
+                if (FailedTryAgain <= 0)
+                {
+                    Status = EOperationStatus.Failed;
+                    _steps = ESteps.Done;
+                    YooLogger.Error(Error);
+                    return;
+                }
+
+                _tryAgainTimer += Time.unscaledDeltaTime;
+                if (_tryAgainTimer > 1f)
+                {
+                    FailedTryAgain--;
+                    _steps = ESteps.CreateRequest;
+                    YooLogger.Warning(Error);
+                }
+            }
+        }
+        internal override void InternalAbort()
+        {
+            _steps = ESteps.Done;
+            DisposeWebRequest();
+        }
+        internal override void InternalWaitForAsyncComplete()
+        {
+            while (true)
+            {
+                //TODO 如果是导入或解压本地文件，执行等待完毕
+                if (_isReuqestLocalFile)
+                {
+                    InternalUpdate();
+                    if (IsDone)
+                        break;
+                }
+                else
+                {
+                    if (ExecuteWhileDone())
+                    {
+                        _steps = ESteps.Done;
+                        break;
+                    }
+                }
+            }
+        }
+
+        private void CreateWebRequest(long beginLength)
+        {
+            _webRequest = DownloadSystemHelper.NewUnityWebRequestGet(_requestURL);
+#if UNITY_2019_4_OR_NEWER
+            var handler = new DownloadHandlerFile(_tempFilePath, true);
+            handler.removeFileOnAbort = false;
+#else
+            var handler = new DownloadHandlerFileRange(FileSavePath, Bundle.FileSize, _webRequest);
+            _downloadHandle = handler;
+#endif
+            _webRequest.downloadHandler = handler;
+            _webRequest.disposeDownloadHandlerOnDispose = true;
+            if (beginLength > 0)
+                _webRequest.SetRequestHeader("Range", $"bytes={beginLength}-");
+            _webRequest.SendWebRequest();
+        }
+        private void DisposeWebRequest()
+        {
+            if (_downloadHandle != null)
+            {
+                _downloadHandle.Cleanup();
+                _downloadHandle = null;
+            }
+
+            if (_webRequest != null)
+            {
+                //注意：引擎底层会自动调用Abort方法
+                _webRequest.Dispose();
+                _webRequest = null;
+            }
+        }
+        private void ClearTempFileWhenError()
+        {
+            if (_fileSystem.ResumeDownloadResponseCodes == null)
+                return;
+
+            //说明：如果遇到以下错误返回码，验证失败直接删除文件
+            if (_fileSystem.ResumeDownloadResponseCodes.Contains(HttpCode))
+            {
+                if (File.Exists(_tempFilePath))
+                    File.Delete(_tempFilePath);
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/DownloadResumeFileOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9bfb785912326f942a31dc77762eb16a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/LoadCachePackageHashOperation.cs

@@ -0,0 +1,64 @@
+using System.IO;
+
+namespace YooAsset
+{
+    internal class LoadCachePackageHashOperation : AsyncOperationBase
+    {
+        private enum ESteps
+        {
+            None,
+            LoadPackageHash,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private readonly string _packageVersion;
+        private ESteps _steps = ESteps.None;
+
+        /// <summary>
+        /// 包裹哈希值
+        /// </summary>
+        public string PackageHash { private set; get; }
+
+
+        internal LoadCachePackageHashOperation(DefaultCacheFileSystem fileSystem, string packageVersion)
+        {
+            _fileSystem = fileSystem;
+            _packageVersion = packageVersion;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.LoadPackageHash;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.LoadPackageHash)
+            {
+                string filePath = _fileSystem.GetCachePackageHashFilePath(_packageVersion);
+                if (File.Exists(filePath) == false)
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = $"Can not found cache package hash file : {filePath}";
+                    return;
+                }
+
+                PackageHash = FileUtility.ReadAllText(filePath);
+                if (string.IsNullOrEmpty(PackageHash))
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = $"Cache package hash file content is empty !";
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+            }
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/LoadCachePackageHashOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: db66f75d31bfeca4e897e9ee0946b1de
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/LoadCachePackageManifestOperation.cs

@@ -0,0 +1,107 @@
+using System.IO;
+
+namespace YooAsset
+{
+    internal class LoadCachePackageManifestOperation : AsyncOperationBase
+    {
+        private enum ESteps
+        {
+            None,
+            LoadFileData,
+            VerifyFileData,
+            LoadManifest,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private readonly string _packageVersion;
+        private readonly string _packageHash;
+        private DeserializeManifestOperation _deserializer;
+        private byte[] _fileData;
+        private ESteps _steps = ESteps.None;
+
+        /// <summary>
+        /// 包裹清单
+        /// </summary>
+        public PackageManifest Manifest { private set; get; }
+
+
+        internal LoadCachePackageManifestOperation(DefaultCacheFileSystem fileSystem, string packageVersion, string packageHash)
+        {
+            _fileSystem = fileSystem;
+            _packageVersion = packageVersion;
+            _packageHash = packageHash;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.LoadFileData;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.LoadFileData)
+            {
+                string manifestFilePath = _fileSystem.GetCachePackageManifestFilePath(_packageVersion);
+                if (File.Exists(manifestFilePath))
+                {
+                    _steps = ESteps.VerifyFileData;
+                    _fileData = File.ReadAllBytes(manifestFilePath);
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = $"Can not found cache manifest file : {manifestFilePath}";
+                }
+            }
+
+            if (_steps == ESteps.VerifyFileData)
+            {
+                if (ManifestTools.VerifyManifestData(_fileData, _packageHash))
+                {
+                    _steps = ESteps.LoadManifest;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = "Failed to verify cache package manifest file!";
+                }
+            }
+
+            if (_steps == ESteps.LoadManifest)
+            {
+                if (_deserializer == null)
+                {
+                    _deserializer = new DeserializeManifestOperation(_fileData);
+                    _deserializer.StartOperation();
+                    AddChildOperation(_deserializer);
+                }
+
+                _deserializer.UpdateOperation();
+                Progress = _deserializer.Progress;
+                if (_deserializer.IsDone == false)
+                    return;
+
+                if (_deserializer.Status == EOperationStatus.Succeed)
+                {
+                    _steps = ESteps.Done;
+                    Manifest = _deserializer.Manifest;
+                    Status = EOperationStatus.Succeed;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = _deserializer.Error;
+                }
+            }
+        }
+        internal override string InternalGetDesc()
+        {
+            return $"PackageVersion : {_packageVersion} PackageHash : {_packageHash}";
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/LoadCachePackageManifestOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: acd84795f7cc3e348ab2b6cde03c8a22
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/RequestRemotePackageVersionOperation.cs

@@ -0,0 +1,100 @@
+
+namespace YooAsset
+{
+    internal class RequestRemotePackageVersionOperation : AsyncOperationBase
+    {
+        private enum ESteps
+        {
+            None,
+            RequestPackageVersion,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private readonly bool _appendTimeTicks;
+        private readonly int _timeout;
+        private UnityWebTextRequestOperation _webTextRequestOp;
+        private int _requestCount = 0;
+        private ESteps _steps = ESteps.None;
+
+        /// <summary>
+        /// 包裹版本
+        /// </summary>
+        internal string PackageVersion { set; get; }
+
+
+        internal RequestRemotePackageVersionOperation(DefaultCacheFileSystem fileSystem, bool appendTimeTicks, int timeout)
+        {
+            _fileSystem = fileSystem;
+            _appendTimeTicks = appendTimeTicks;
+            _timeout = timeout;
+        }
+        internal override void InternalStart()
+        {
+            _requestCount = WebRequestCounter.GetRequestFailedCount(_fileSystem.PackageName, nameof(RequestRemotePackageVersionOperation));
+            _steps = ESteps.RequestPackageVersion;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.RequestPackageVersion)
+            {
+                if (_webTextRequestOp == null)
+                {
+                    string fileName = YooAssetSettingsData.GetPackageVersionFileName(_fileSystem.PackageName);
+                    string url = GetWebRequestURL(fileName);
+                    _webTextRequestOp = new UnityWebTextRequestOperation(url, _timeout);
+                    _webTextRequestOp.StartOperation();
+                    AddChildOperation(_webTextRequestOp);
+                }
+
+                _webTextRequestOp.UpdateOperation();
+                Progress = _webTextRequestOp.Progress;
+                if (_webTextRequestOp.IsDone == false)
+                    return;
+
+                if (_webTextRequestOp.Status == EOperationStatus.Succeed)
+                {
+                    PackageVersion = _webTextRequestOp.Result;
+                    if (string.IsNullOrEmpty(PackageVersion))
+                    {
+                        _steps = ESteps.Done;
+                        Status = EOperationStatus.Failed;
+                        Error = $"Remote package version file content is empty !";
+                    }
+                    else
+                    {
+                        _steps = ESteps.Done;
+                        Status = EOperationStatus.Succeed;
+                    }
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = _webTextRequestOp.Error;
+                    WebRequestCounter.RecordRequestFailed(_fileSystem.PackageName, nameof(RequestRemotePackageVersionOperation));
+                }
+            }
+        }
+
+        private string GetWebRequestURL(string fileName)
+        {
+            string url;
+
+            // 轮流返回请求地址
+            if (_requestCount % 2 == 0)
+                url = _fileSystem.RemoteServices.GetRemoteMainURL(fileName);
+            else
+                url = _fileSystem.RemoteServices.GetRemoteFallbackURL(fileName);
+
+            // 在URL末尾添加时间戳
+            if (_appendTimeTicks)
+                return $"{url}?{System.DateTime.UtcNow.Ticks}";
+            else
+                return url;
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/RequestRemotePackageVersionOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1b078a220cc4f7d4392d77ccc77c001e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/SearchCacheFilesOperation.cs

@@ -0,0 +1,126 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YooAsset
+{
+    internal sealed class SearchCacheFilesOperation : AsyncOperationBase
+    {
+        private enum ESteps
+        {
+            None,
+            Prepare,
+            SearchFiles,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private IEnumerator<DirectoryInfo> _filesEnumerator = null;
+        private float _verifyStartTime;
+        private ESteps _steps = ESteps.None;
+
+        /// <summary>
+        /// 需要验证的元素
+        /// </summary>
+        public readonly List<VerifyFileElement> Result = new List<VerifyFileElement>(5000);
+
+
+        internal SearchCacheFilesOperation(DefaultCacheFileSystem fileSystem)
+        {
+            _fileSystem = fileSystem;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.Prepare;
+            _verifyStartTime = UnityEngine.Time.realtimeSinceStartup;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.Prepare)
+            {
+                DirectoryInfo rootDirectory = new DirectoryInfo(_fileSystem.GetCacheBundleFilesRoot());
+                if (rootDirectory.Exists)
+                {
+                    var directorieInfos = rootDirectory.EnumerateDirectories();
+                    _filesEnumerator = directorieInfos.GetEnumerator();
+                }
+                _steps = ESteps.SearchFiles;
+            }
+
+            if (_steps == ESteps.SearchFiles)
+            {
+                if (SearchFiles())
+                    return;
+
+                _steps = ESteps.Done;
+                Status = EOperationStatus.Succeed;
+                float costTime = UnityEngine.Time.realtimeSinceStartup - _verifyStartTime;
+                YooLogger.Log($"Search cache files elapsed time {costTime:f1} seconds");
+            }
+        }
+
+        private bool SearchFiles()
+        {
+            if (_filesEnumerator == null)
+                return false;
+
+            bool isFindItem;
+            while (true)
+            {
+                isFindItem = _filesEnumerator.MoveNext();
+                if (isFindItem == false)
+                    break;
+
+                var rootFoder = _filesEnumerator.Current;
+                var childDirectories = rootFoder.GetDirectories();
+                foreach (var chidDirectory in childDirectories)
+                {
+                    string bundleGUID = chidDirectory.Name;
+                    if (_fileSystem.IsRecordBundleFile(bundleGUID))
+                        continue;
+
+                    // 创建验证元素类
+                    string fileRootPath = chidDirectory.FullName;
+                    string dataFilePath = $"{fileRootPath}/{DefaultCacheFileSystemDefine.BundleDataFileName}";
+                    string infoFilePath = $"{fileRootPath}/{DefaultCacheFileSystemDefine.BundleInfoFileName}";
+
+                    // 存储的数据文件追加文件格式
+                    if (_fileSystem.AppendFileExtension)
+                    {
+                        string dataFileExtension = FindDataFileExtension(chidDirectory);
+                        if (string.IsNullOrEmpty(dataFileExtension) == false)
+                        {
+                            dataFilePath += dataFileExtension;
+                        }
+                    }
+
+                    var element = new VerifyFileElement(_fileSystem.PackageName, bundleGUID, fileRootPath, dataFilePath, infoFilePath);
+                    Result.Add(element);
+                }
+
+                if (OperationSystem.IsBusy)
+                    break;
+            }
+
+            return isFindItem;
+        }
+        private string FindDataFileExtension(DirectoryInfo directoryInfo)
+        {
+            string dataFileExtension = string.Empty;
+            var fileInfos = directoryInfo.GetFiles();
+            foreach (var fileInfo in fileInfos)
+            {
+                if (fileInfo.Name.StartsWith(DefaultCacheFileSystemDefine.BundleDataFileName))
+                {
+                    dataFileExtension = fileInfo.Extension;
+                    break;
+                }
+            }
+            return dataFileExtension;
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/SearchCacheFilesOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8adb017a806563548b1d4c47f7b343e2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/VerifyCacheFilesOperation.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+
+namespace YooAsset
+{
+    /// <summary>
+    /// 缓存文件验证（线程版）
+    /// </summary>
+    internal sealed class VerifyCacheFilesOperation : AsyncOperationBase
+    {
+        private enum ESteps
+        {
+            None,
+            InitVerify,
+            UpdateVerify,
+            Done,
+        }
+
+        private readonly DefaultCacheFileSystem _fileSystem;
+        private readonly EFileVerifyLevel _fileVerifyLevel;
+        private List<VerifyFileElement> _waitingList;
+        private List<VerifyFileElement> _verifyingList;
+        private int _verifyMaxNum;
+        private int _verifyTotalCount;
+        private float _verifyStartTime;
+        private int _succeedCount;
+        private int _failedCount;
+        private ESteps _steps = ESteps.None;
+
+
+        internal VerifyCacheFilesOperation(DefaultCacheFileSystem fileSystem, List<VerifyFileElement> elements)
+        {
+            _fileSystem = fileSystem;
+            _waitingList = elements;
+            _fileVerifyLevel = fileSystem.FileVerifyLevel;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.InitVerify;
+            _verifyStartTime = UnityEngine.Time.realtimeSinceStartup;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.InitVerify)
+            {
+                int fileCount = _waitingList.Count;
+
+                // 设置同时验证的最大数
+                ThreadPool.GetMaxThreads(out int workerThreads, out int ioThreads);
+                YooLogger.Log($"Work threads : {workerThreads}, IO threads : {ioThreads}");
+                _verifyMaxNum = Math.Min(workerThreads, ioThreads);
+                _verifyTotalCount = fileCount;
+                if (_verifyMaxNum < 1)
+                    _verifyMaxNum = 1;
+
+                _verifyingList = new List<VerifyFileElement>(_verifyMaxNum);
+                _steps = ESteps.UpdateVerify;
+            }
+
+            if (_steps == ESteps.UpdateVerify)
+            {
+                // 检测校验结果
+                for (int i = _verifyingList.Count - 1; i >= 0; i--)
+                {
+                    var verifyElement = _verifyingList[i];
+                    int result = verifyElement.Result;
+                    if (result != 0)
+                    {
+                        _verifyingList.RemoveAt(i);
+                        RecordVerifyFile(verifyElement);
+                    }
+                }
+
+                Progress = GetProgress();
+                if (_waitingList.Count == 0 && _verifyingList.Count == 0)
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                    float costTime = UnityEngine.Time.realtimeSinceStartup - _verifyStartTime;
+                    YooLogger.Log($"Verify cache files elapsed time {costTime:f1} seconds");
+                }
+
+                for (int i = _waitingList.Count - 1; i >= 0; i--)
+                {
+                    if (OperationSystem.IsBusy)
+                        break;
+
+                    if (_verifyingList.Count >= _verifyMaxNum)
+                        break;
+
+                    var element = _waitingList[i];
+                    bool succeed = ThreadPool.QueueUserWorkItem(new WaitCallback(VerifyInThread), element);
+                    if (succeed)
+                    {
+                        _waitingList.RemoveAt(i);
+                        _verifyingList.Add(element);
+                    }
+                    else
+                    {
+                        YooLogger.Warning("The thread pool is failed queued.");
+                        break;
+                    }
+                }
+            }
+        }
+
+        private float GetProgress()
+        {
+            if (_verifyTotalCount == 0)
+                return 1f;
+            return (float)(_succeedCount + _failedCount) / _verifyTotalCount;
+        }
+        private void VerifyInThread(object obj)
+        {
+            VerifyFileElement element = (VerifyFileElement)obj;
+            int verifyResult = (int)VerifyingCacheFile(element, _fileVerifyLevel);
+            element.Result = verifyResult;
+        }
+        private void RecordVerifyFile(VerifyFileElement element)
+        {
+            if (element.Result == (int)EFileVerifyResult.Succeed)
+            {
+                _succeedCount++;
+                var recordFileElement = new RecordFileElement(element.InfoFilePath, element.DataFilePath, element.DataFileCRC, element.DataFileSize);
+                _fileSystem.RecordBundleFile(element.BundleGUID, recordFileElement);
+            }
+            else
+            {
+                _failedCount++;
+                YooLogger.Warning($"Failed to verify file {element.Result} and delete files : {element.FileRootPath}");
+                element.DeleteFiles();
+            }
+        }
+
+        /// <summary>
+        /// 验证缓存文件（子线程内操作）
+        /// </summary>
+        private EFileVerifyResult VerifyingCacheFile(VerifyFileElement element, EFileVerifyLevel verifyLevel)
+        {
+            try
+            {
+                if (verifyLevel == EFileVerifyLevel.Low)
+                {
+                    if (File.Exists(element.InfoFilePath) == false)
+                        return EFileVerifyResult.InfoFileNotExisted;
+                    if (File.Exists(element.DataFilePath) == false)
+                        return EFileVerifyResult.DataFileNotExisted;
+                    return EFileVerifyResult.Succeed;
+                }
+                else
+                {
+                    if (File.Exists(element.InfoFilePath) == false)
+                        return EFileVerifyResult.InfoFileNotExisted;
+
+                    // 解析信息文件获取验证数据
+                    _fileSystem.ReadBundleInfoFile(element.InfoFilePath, out element.DataFileCRC, out element.DataFileSize);
+                }
+            }
+            catch (Exception)
+            {
+                return EFileVerifyResult.Exception;
+            }
+
+            return FileVerifyHelper.FileVerify(element.DataFilePath, element.DataFileSize, element.DataFileCRC, verifyLevel);
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/VerifyCacheFilesOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5e9325baa24ae234ea0208d70dd3347e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/VerifyTempFileOperation.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Threading;
+
+namespace YooAsset
+{
+    /// <summary>
+    /// 下载文件验证（线程版）
+    /// </summary>
+    internal sealed class VerifyTempFileOperation : AsyncOperationBase
+    {
+        private enum ESteps
+        {
+            None,
+            VerifyFile,
+            Waiting,
+            Done,
+        }
+
+        private readonly TempFileElement _element;
+        private ESteps _steps = ESteps.None;
+
+        /// <summary>
+        /// 验证结果
+        /// </summary>
+        public EFileVerifyResult VerifyResult { private set; get; }
+
+
+        internal VerifyTempFileOperation(TempFileElement element)
+        {
+            _element = element;
+        }
+        internal override void InternalStart()
+        {
+            _steps = ESteps.VerifyFile;
+        }
+        internal override void InternalUpdate()
+        {
+            if (_steps == ESteps.None || _steps == ESteps.Done)
+                return;
+
+            if (_steps == ESteps.VerifyFile)
+            {
+                bool succeed = ThreadPool.QueueUserWorkItem(new WaitCallback(VerifyInThread), _element);
+                if (succeed)
+                {
+                    _steps = ESteps.Waiting;
+                }
+            }
+
+            if (_steps == ESteps.Waiting)
+            {
+                int result = _element.Result;
+                if (result == 0)
+                    return;
+
+                VerifyResult = (EFileVerifyResult)result;
+                if (VerifyResult == EFileVerifyResult.Succeed)
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Succeed;
+                }
+                else
+                {
+                    _steps = ESteps.Done;
+                    Status = EOperationStatus.Failed;
+                    Error = $"Failed to verify file : {_element.TempFilePath} ! ErrorCode : {VerifyResult}";
+                }
+            }
+        }
+        internal override void InternalWaitForAsyncComplete()
+        {
+            while (true)
+            {
+                //TODO 等待子线程验证文件完毕，该操作会挂起主线程
+                InternalUpdate();
+                if (IsDone)
+                    break;
+            }
+        }
+
+        private void VerifyInThread(object obj)
+        {
+            TempFileElement element = (TempFileElement)obj;
+            int result = (int)FileVerifyHelper.FileVerify(element.TempFilePath, element.TempFileSize, element.TempFileCRC, EFileVerifyLevel.High);
+            element.Result = result;
+        }
+    }
+}

UnityProject/Packages/YooAsset/Runtime/FileSystem/DefaultCacheFileSystem/Operation/internal/VerifyTempFileOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 764ac4f47afd3be4a8d583578f51126d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: