Пример #1
0
    private IEnumerator Load(Action <string, float> loadProgress = null)
    {
        yield return(new WaitForEndOfFrame());

        for (int i = 0; i < AllABPath.Count; i++)
        {
            int index = i;
            //根据依赖包名称进行加载
            UnityWebRequester requester = new UnityWebRequester(App.app);
            requester.GetAssetBundle($"{mainfestPath}/{AllABPath[index]}", (AssetBundle ab) =>
            {
                if (!AssetBundlesCache.ContainsKey(AllABPath[index]))
                {
                    //注意添加进缓存 防止重复加载AB包
                    AssetBundlesCache.Add(AllABPath[index], ab);
                }
            });
            while (!requester.IsDown)
            {
                float progress = requester.DownloadedProgress;
                loadProgress?.Invoke(AllABPath[index], progress);
            }
            yield return(new WaitForEndOfFrame());

            loadProgress?.Invoke(AllABPath[index], 1);
        }
    }
Пример #2
0
        /// <summary> 下载 </summary>
        private void DownLoad(string url, Action <byte[]> action)
        {
            UnityWebRequester requester = new UnityWebRequester(App.app);

            requester.GetBytes(url, (byte[] data) =>
            {
                action?.Invoke(data);
                requester.Destory();
            });
        }
Пример #3
0
 public void LoadAssetBundle(Action <string, float> loadProgress = null)
 {
     if (assetbundle == null)
     {
         UnityWebRequester requester = new UnityWebRequester(App.app);
         requester.GetAssetBundle($"{mainfestPath}/{PlatformManager.Instance.Name}", (AssetBundle ab) =>
         {
             assetbundle = ab;
             manifest    = assetbundle.LoadAsset <AssetBundleManifest>("AssetBundleManifest");
             GetAssetBundlePath(loadProgress);
             requester.Destory();
         });
         return;
     }
     GetAssetBundlePath(loadProgress);
 }
Пример #4
0
 private void DownLoadAssetBundle()
 {
     unityWebRequesterPairs.Clear();
     for (int i = 0; i < downloadScenes.Count; i++)
     {
         _indexI = i;
         for (int j = 0; j < downloadScenes[i].Folders.Count; j++)
         {
             _indexJ = j;
             var folder = downloadScenes[_indexI].Folders[_indexJ];
             // Debug.Log(folder.BundleName);
             //添加到下载列表
             if (unityWebRequesterPairs.ContainsKey(folder))
             {
                 continue;
             }
             UnityWebRequester requester = new UnityWebRequester(App.app);
             unityWebRequesterPairs.Add(folder, requester);
             //下载manifest文件
             DownLoad(ServerUrl + folder.BundleName + ".manifest", (byte[] _manifest_data) =>
             {
                 //将manifest文件写入本地
                 FileManager.CreateFile(LocalPath + folder.BundleName + ".manifest", _manifest_data);
             });
         }
     }
     foreach (var requester in unityWebRequesterPairs)
     {
         unityWebRequester = requester.Value;
         requester.Value.GetBytes(ServerUrl + requester.Key.BundleName, (byte[] data) =>
         {
             FileManager.CreateFile(LocalPath + requester.Key.BundleName, data);
             unityWebRequester = null;
             alreadyDownLoadList.Add(requester.Key);
             //下载完成后修改本地版本文件
             UpdateLocalConfig(requester.Key);
         });
     }
 }
        private IEnumerator Coro_Progress(LoadingData load)
        {
            for (int i = 0; i < load.coroutines.Count; i++)
            {
                yield return(load.coroutines[i]);

                if (load.forceClose)
                {
                    yield break;
                }
            }

            if (load.resources.Count > 0)
            {
                int srcLoadCount = load.resources.Count;

                foreach (var task in load.resources)
                {
                    task.status = TaskStatus.Pending;
                    ResourceManagement.ResourceManager.Load(new ResourceManagement.ResourceManager.LoadTask()
                    {
                        path      = System.IO.Path.Combine(task.path, task.name),
                        type      = task.type,
                        completed = assets =>
                        {
                            if (assets.Length > 0)
                            {
                                task.loadedObj = assets[0];
                            }
                            srcLoadCount--;
                            task.status = TaskStatus.Ready;
                        }
                    });
                }
                yield return(new WaitUntil(() => srcLoadCount == 0));
            }

            if (load.parallelHttpGroup.Groups.Count > 0)
            {
                foreach (DictionaryEntry e in load.parallelHttpGroup.Groups)
                {
                    if (httpWrapper == null)
                    {
                        httpWrapper = HttpRequesterWrapper.Create();
                        DontDestroyOnLoad(httpWrapper.gameObject);
                    }

                    ParallelHttp https = (ParallelHttp)e.Value;

                    foreach (DictionaryEntry e1 in https.Https)
                    {
                        var task = (HttpRequestTask)e1.Value;
                        task.status = TaskStatus.Pending;
                        if (task.req == null)
                        {
                            task.status = TaskStatus.Ready;
                            continue;
                        }
                        var req = UnityWebRequester.Create();
                        req.SetOnSuccess(res =>
                        {
                            task.res     = res;
                            task.resCode = res.ResponseCode;
                            task.resData = res.ResponseText;
                            task.resTex  = res.ResponseTexture;
                            if (task.onSuccess != null)
                            {
                                task.onSuccess(task);
                            }
                        });
                        req.SetOnFailure(res =>
                        {
                            task.res     = res;
                            task.resCode = res.ResponseCode;
                            task.resFail = res.ResponseText;
                            if (task.onFailed != null)
                            {
                                task.onFailed(task.resFail);
                            }
                        });
                        req.SetOnError(res =>
                        {
                            task.res      = res;
                            task.resCode  = res.ResponseCode;
                            task.resError = res.ResponseError;
                            if (task.onFailed != null)
                            {
                                task.onFailed(task.resError);
                            }
                        });
                        req.SetOnFinish(() =>
                        {
                            task.status = TaskStatus.Ready;
                        });
                        req.AddRequest(task.req);
                        httpWrapper.SendRequest(req);
                    }

                    yield return(new WaitUntil(() => httpWrapper == null || httpWrapper.IsEmpty));

                    if (load.forceClose)
                    {
                        yield break;
                    }

                    bool forceBreak = false;

                    foreach (DictionaryEntry e1 in https.Https)
                    {
                        var task = (HttpRequestTask)e1.Value;
                        if (task.abortIfFail && (string.IsNullOrEmpty(task.resFail) == false || string.IsNullOrEmpty(task.resError) == false))
                        {
                            forceBreak = true;
                            break;
                        }
                    }

                    if (forceBreak)
                    {
                        break;
                    }
                }

                DestroyHttpWrapper();
            }

            foreach (var kv in load.https)
            {
                var task = kv.Value;
                task.status = TaskStatus.Pending;
                if (task.req == null)
                {
                    task.status = TaskStatus.Ready;
                    continue;
                }
                bool pending   = true;
                bool failed    = false;
                var  reqSender = UnityWebRequester.Create();
                reqSender.SetOnSuccess(res =>
                {
                    task.res     = res;
                    task.resCode = res.ResponseCode;
                    task.resData = res.ResponseText;
                    task.resTex  = res.ResponseTexture;
                    if (task.onSuccess != null)
                    {
                        task.onSuccess(task);
                    }
                });
                reqSender.SetOnFailure(res =>
                {
                    task.res     = res;
                    task.resCode = res.ResponseCode;
                    task.resFail = res.ResponseText;
                    failed       = true;
                    if (task.onFailed != null)
                    {
                        task.onFailed(task.resFail);
                    }
                });
                reqSender.SetOnError(res =>
                {
                    task.res      = res;
                    task.resCode  = res.ResponseCode;
                    task.resError = res.ResponseError;
                    failed        = true;
                    if (task.onFailed != null)
                    {
                        task.onFailed(task.resError);
                    }
                });
                reqSender.SetOnFinish(() =>
                {
                    pending     = false;
                    task.status = TaskStatus.Ready;
                });
                reqSender.AddRequest(task.req);
                reqSender.Send();

                // Wait request pending...
                yield return(new WaitWhile(() => pending));

                if (load.forceClose)
                {
                    yield break;
                }

                if (failed && task.abortIfFail)
                {
                    break;
                }
            }

            if (load.forceClose)
            {
                yield break;
            }

            for (int i = 0; i < load.lateCoroutines.Count; i++)
            {
                yield return(load.lateCoroutines[i]);

                if (load.forceClose)
                {
                    yield break;
                }
            }
        }