Work with external resources in Unity3D

IEnumerator LoadAssetBundleFromServerWithCache(string url, Action<AssetBundle> response)
{
    // Ждем, готовности системы кэшированияwhile (!Caching.ready)
    {
        yieldreturnnull;
    }
    // получаем манифест с сервераvar request = UnityWebRequest.Get(url + ".manifest");
    yieldreturn request.SendWebRequest();
    if (!request.isHttpError && !request.isNetworkError)
    {
        Hash128 hash = default;
        //получаем hashvar hashRow = request.downloadHandler.text.ToString().Split("\n".ToCharArray())[5];
        hash = Hash128.Parse(hashRow.Split(':')[1].Trim());
        if (hash.isValid == true)
        {
            request.Dispose();
            request = UnityWebRequestAssetBundle.GetAssetBundle(url, hash, 0);
            yieldreturn request.SendWebRequest();
            if (!request.isHttpError && !request.isNetworkError)
            {
                response(DownloadHandlerAssetBundle.GetContent(request));
            }
            else
            {
                response(null);
            }
        }
        else
        {
            response(null);
        }
    }
    else
    {
        response(null);
    }
    request.Dispose();
}

publicclassAssetBundleWrapper
{
#if UNITY_EDITORprivatereadonly List<string> _assets;
        publicAssetBundleWrapper(string url)
        {
            var uri = new Uri(url);
            var bundleName = Path.GetFileNameWithoutExtension(uri.LocalPath);
            _assets = new List<string>(AssetDatabase.GetAssetPathsFromAssetBundle(bundleName));           
        }
        public T LoadAsset<T>(string name) where T : UnityEngine.Object
        {
            var assetPath = _assets.Find(item =>
            {
                var assetName = Path.GetFileNameWithoutExtension(item);
                returnstring.CompareOrdinal(name, assetName) == 0;                
            });
            if (!string.IsNullOrEmpty(assetPath))
            {
                return AssetDatabase.LoadAssetAtPath<T>(assetPath);
            } else
            {
                returndefault;
            }
        }
        public T[] LoadAssets<T>() where T : UnityEngine.Object
        {
            var returnedValues = new List<T>();
            foreach(var assetPath in _assets)
            {
                returnedValues.Add(AssetDatabase.LoadAssetAtPath<T>(assetPath));
            }
            return returnedValues.ToArray();
        }
        publicvoid LoadAssetAsync<T>(string name, Action<T> result) where T : UnityEngine.Object
        {
            result(LoadAsset<T>(name));
        }
        publicvoid LoadAssetsAsync<T>(Action<T[]> result) where T : UnityEngine.Object
        {
            result(LoadAssets<T>());
        }
        publicstring[] GetAllScenePaths()
        {
            return _assets.ToArray();
        }
        publicvoidUnload(bool includeAllLoadedAssets = false)
        {
            _assets.Clear();
        }
#elseprivatereadonly AssetBundle _assetBundle;
    publicAssetBundleWrapper(AssetBundle assetBundle)
    {
        _assetBundle = assetBundle;
    }
    public T LoadAsset<T>(string name) where T : UnityEngine.Object
    {
        return _assetBundle.LoadAsset<T>(name);
    }
    public T[] LoadAssets<T>() where T : UnityEngine.Object
    {
        return _assetBundle.LoadAllAssets<T>();
    }
    publicvoid LoadAssetAsync<T>(string name, Action<T> result) where T : UnityEngine.Object
    {
        var request = _assetBundle.LoadAssetAsync<T>(name);
        TaskManager.Task.Create(request)
                        .Subscribe(() =>
                        {
                            result(request.asset as T);
                            Unload(false);
                        })
                        .Start();
    }
    publicvoid LoadAssetsAsync<T>(Action<T[]> result) where T : UnityEngine.Object
    {
        var request = _assetBundle.LoadAllAssetsAsync<T>();
        TaskManager.Task.Create(request)
                        .Subscribe(() =>
                        {
                            var assets = new T[request.allAssets.Length];
                            for (var i = 0; i < request.allAssets.Length; i++)
                            {
                                assets[i] = request.allAssets[i] as T;
                            }
                            result(assets);
                            Unload(false);
                        })
                        .Start();
    }
    publicstring[] GetAllScenePaths()
    {
        return _assetBundle.GetAllScenePaths();
    }
    publicvoidUnload(bool includeAllLoadedAssets = false)
    {
        _assetBundle.Unload(includeAllLoadedAssets);
    }
#endif
}

private IEnumerator WebRequest(UnityWebRequest request, Action<float> progress, Action<UnityWebRequest> response)
{
    while (!Caching.ready)
    {
        yieldreturnnull;
    }
    if (progress != null)
    {
        request.SendWebRequest(); _currentRequests.Add(request);
        while (!request.isDone)
        {
            progress(request.downloadProgress);
            yieldreturnnull;
        }
        progress(1f);
    }
    else
    {
        yieldreturn request.SendWebRequest();
    }
    response(request);
    if (_currentRequests.Contains(request))
    {
        _currentRequests.Remove(request);
    }
    request.Dispose();
}

private IEnumerator WebRequestBundle(string url, Hash128 hash, Action<float> progress, Action<UnityWebRequest> response)
{
    var request = UnityWebRequestAssetBundle.GetAssetBundle(url, hash, 0);
    return WebRequest(request, progress, response);
}

private IEnumerator WebRequestPost(string url, Dictionary<string, string> formFields, Action<float> progress, Action<UnityWebRequest> response)
{
    var request = UnityWebRequest.Post(url, formFields);
    return WebRequest(request, progress, response);
}

private IEnumerator WebRequestPost(string url, string data, Action<float> progress, Action<UnityWebRequest> response)
{
    var request = new UnityWebRequest(url, UnityWebRequest.kHttpVerbPOST)
    {
        uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(data)),
        downloadHandler = new DownloadHandlerBuffer()
    };
    request.uploadHandler.contentType = "application/json";
    return WebRequest(request, progress, response);
}

publicvoidRequest(string url, Hash128 hash, Action<float> progress, Action<AssetBundle> response, TaskManager.TaskPriorityEnum priority = TaskManager.TaskPriorityEnum.Default)
{
        _taskManager.AddTask(WebRequestBundle(url, hash, progress, (uwr) =>
        {
            if (!uwr.isHttpError && !uwr.isNetworkError)
            {
                response(DownloadHandlerAssetBundle.GetContent(uwr));
            }
            else
            {
                Debug.LogWarningFormat("[Netowrk]: error request [{0}]", uwr.error);
                response(null);
            }
        }), priority);
}

publicvoidRequest(string url, Action<int> response, TaskManager.TaskPriorityEnum priority = TaskManager.TaskPriorityEnum.Default)
{
    var request = UnityWebRequest.Head(url);
        _taskManager.AddTask(WebRequest(request, null, uwr =>
        {
            var contentLength = uwr.GetResponseHeader("Content-Length");
            if (int.TryParse(contentLength, outint returnValue))
            {
                response(returnValue);
            }
            else
            {
                response(-1);
            }
        }), priority);
}
publicvoidClear()
{
    _taskManager.Clear();
    foreach (var request in _currentRequests)
    {
        request.Abort();
        request.Dispose();
    }
    _currentRequests.Clear();    
}

publicclassExternalResourceManager
{
    publicenum ResourceEnumType
    {
        Text,
        Texture,
        AssetBundle
    }
    privatereadonly Network _network = new Network();
    publicvoidExternalResourceManager()
    {
#if UNITY_EDITORvar path = Path.Combine(Directory.GetParent(Application.dataPath).FullName,   "_EditorCache");
#elsevar path = Path.Combine(Application.persistentDataPath, "_AppCache");                                
#endifif (!System.IO.Directory.Exists(path))
       {
           System.IO.Directory.CreateDirectory(path);
           #if UNITY_IOS
	    UnityEngine.iOS.Device.SetNoBackupFlag(path);			     		  
           #endif
       }
       Caching.currentCacheForWriting = Caching.AddCache(path);
    }
}

publicvoidClearAssetBundleCache(string url)
{
    var fileName = GetFileNameFromUrl(url);            
     Caching.ClearAllCachedVersions(fileName);
}
publicvoidClearAllRequest()
{
    _network.Clear();
}
publicvoidAssetBundleIsCached(string url, Action<bool> result)
{
var manifestFileUrl = "{0}.manifest".Fmt(url);
_network.Request(manifestFileUrl, null, (string manifest) =>
{
                var hash = string.IsNullOrEmpty(manifest) ? default : GetHashFromManifest(manifest);
                result(Caching.IsVersionCached(url, hash));
} , 
TaskManager.TaskPriorityEnum.RunOutQueue);
}
publicvoidCheckFreeSpace(string url, Action<bool, float> result)
{
    GetSize(url, lengthInMb =>
    {
#if UNITY_EDITOR_WINvar logicalDrive = Path.GetPathRoot(Utils.Path.Cache);
        var availableSpace = SimpleDiskUtils.DiskUtils.CheckAvailableSpace(logicalDrive);
#elif UNITY_EDITOR_OSXvar availableSpace = SimpleDiskUtils.DiskUtils.CheckAvailableSpace();
#elif UNITY_IOSvar availableSpace = SimpleDiskUtils.DiskUtils.CheckAvailableSpace();
#elif UNITY_ANDROIDvar availableSpace = SimpleDiskUtils.DiskUtils.CheckAvailableSpace(true);
#endif
        result(availableSpace > lengthInMb, lengthInMb);
    });
}
publicvoidGetSize(string url, Action<float> result)
{
    _network.Request(url, length => result(length / 1048576f));
}
privatestringGetFileNameFromUrl(string url)
{
    var uri = new Uri(url);
    var fileName = Path.GetFileNameWithoutExtension(uri.LocalPath);
    return fileName;
}
private Hash128 GetHashFromManifest(string manifest)
{
    var hashRow = manifest.Split("\n".ToCharArray())[5];
    var hash = Hash128.Parse(hashRow.Split(':')[1].Trim());
    return hash;
}

publicvoidGetAssetBundle(string url,
                           Action start,
                           Action<float> progress,
                           Action stop,
                           Action<AssetBundleWrapper> result,
                           TaskManager.TaskPriorityEnum taskPriority = TaskManager.TaskPriorityEnum.Default)
{
#if DONT_USE_SERVER_IN_EDITOR
    start?.Invoke();
    result(new AssetBundleWrapper(url));
    stop?.Invoke();
#elsevoidloadAssetBundle(Hash128 bundleHash)
{
    start?.Invoke();
    _network.Request(url, bundleHash, progress,
    (AssetBundle value) =>
    {   
        if(value != null)
        {
            _externalResourcesStorage.SetCachedHash(url, bundleHash);
        }
        result(new AssetBundleWrapper(value));
        stop?.Invoke();
    }, taskPriority);
};
var manifestFileUrl = "{0}.manifest".Fmt(url);
_network.Request(manifestFileUrl, null, (string manifest) =>
{
    var hash = string.IsNullOrEmpty(manifest) ? default : GetHashFromManifest(manifest);                                
    if (!hash.isValid || hash == default)
    {
        hash = _externalResourcesStorage.GetCachedHash(url);                    
        if (!hash.isValid || hash == default)
        {
            result(new AssetBundleWrapper(null));
        }
        else
        {
            loadAssetBundle(hash);
        }
    }
    else
    {                    
        if (Caching.IsVersionCached(url, hash))
        {
            loadAssetBundle(hash);
        }
        else
        {
            CheckFreeSpace(url, (spaceAvailable, length) =>
            {
                if (spaceAvailable)
                {
                    loadAssetBundle(hash);
                }
                else
                {
                     result(new AssetBundleWrapper(null));
                    NotEnoughDiskSpace.Call();
                }
             });
         }
    }
#endif
}

publicvoidGetPack(Dictionary<string, ResourceEnumType> urls, 
                            Action start,
                            Action<float> progress,
                            Action stop, Action<string, object, bool> result)
{            
    var commonProgress = (float)urls.Count;
    var currentProgress = 0f;
    var completeCounter = 0;
    voidprogressHandler(floatvalue)            
    {
        currentProgress += value;                
        progress?.Invoke(currentProgress / commonProgress);                
    };
    voidcompleteHandler()
    {
        completeCounter++;
        if (completeCounter == urls.Count)
        {
            stop?.Invoke();
        }
    };
    start?.Invoke();
    foreach (var url in urls.Keys)
    {
        var resourceType = urls[url];
        switch (resourceType)
        {
            case ResourceEnumType.Text:
                {
                    GetText(url, null, progressHandler, completeHandler,
                                    (value, isCached) =>
                                    {
                                        result(url, value, isCached);
                                    });
                }
                break;
            case ResourceEnumType.Texture:
                {
                    GetTexture(url, null, progressHandler, completeHandler,
                                       (value, isCached) =>
                                       {
                                           result(url, value, isCached);
                                       });
                }
                break;
            case ResourceEnumType.AssetBundle:
                {
                    GetAssetBundle(url, null, progressHandler, completeHandler,
                                           (value) =>
                                           {
                                               result(url, value, false);
                                           });
                }
                break;
        }
    }
}