public LoadingTask(IProgressPromise <TProgress, TResult> result, IEnumerator routine, BundleLoader loader)
{
this.result = result;
this.routine = routine;
this.loader = loader;
this.startTime = System.DateTime.Now.Ticks / 10000;
}
protected virtual IEnumerator DoAnalyzeDownloadList(IProgressPromise <float, List <BundleInfo> > promise, BundleManifest manifest)
{
List <BundleInfo> downloads = new List <BundleInfo>();
BundleInfo[] bundleInfos = manifest.GetAll();
float last = Time.realtimeSinceStartup;
int length = bundleInfos.Length;
for (int i = 0; i < bundleInfos.Length; i++)
{
BundleInfo info = bundleInfos[i];
if (Time.realtimeSinceStartup - last > 0.15f)
{
yield return(null);
last = Time.realtimeSinceStartup;
}
promise.UpdateProgress(i + 1 / (float)length);
if (BundleUtil.Exists(info))
{
continue;
}
downloads.Add(info);
}
promise.SetResult(downloads);
}
protected virtual IEnumerator DoLoadAssetsAsync <T>(IProgressPromise <float, T[]> promise, params string[] names) where T : Object
{
List <T> results = new List <T>();
int count = names.Length;
float progress = 0f;
foreach (string name in names)
{
var fullName = GetFullName(name);
AssetBundleRequest request = this.AssetBundle.LoadAssetAsync <T>(fullName);
while (!request.isDone)
{
promise.UpdateProgress(progress + request.progress / count);
yield return(null);
}
progress += 1f / count;
T asset = (T)request.asset;
if (asset != null)
{
results.Add(asset);
}
}
promise.UpdateProgress(1f);
promise.SetResult(results.ToArray());
}
/// <summary>
/// Simulate a task.
/// </summary>
/// <returns>The task.</returns>
/// <param name="promise">Promise.</param>
protected void DoTask(IProgressPromise <float, string> promise)
{
try
{
int n = 50;
float progress = 0f;
StringBuilder buf = new StringBuilder();
for (int i = 0; i < n; i++)
{
/* If the task is cancelled, then stop the task */
if (promise.IsCancellationRequested)
{
promise.SetCancelled();
break;
}
progress = i / (float)n;
buf.Append(" ").Append(i);
promise.UpdateProgress(progress);/* update the progress of task. */
#if NETFX_CORE
Task.Delay(200).Wait();
#else
Thread.Sleep(200);
#endif
}
promise.UpdateProgress(1f);
promise.SetResult(buf.ToString()); /* update the result. */
}
catch (System.Exception e)
{
promise.SetException(e);
}
}
protected virtual IEnumerator DoLoadAssetAsync <T>(IProgressPromise <float, T> promise, string name) where T : Object
{
string key = Key(name, typeof(T));
AssetBundleRequest request;
if (!this.requestCache.TryGetValue(key, out request))
{
var fullName = GetFullName(name);
request = this.AssetBundle.LoadAssetAsync <T>(fullName);
this.requestCache.Add(key, request);
}
while (!request.isDone)
{
promise.UpdateProgress(request.progress);
yield return(null);
}
this.requestCache.Remove(key);
Object asset = request.asset;
if (asset == null)
{
promise.SetException(new System.Exception(string.Format("Not found the asset '{0}'.", name)));
yield break;
}
promise.UpdateProgress(1f);
promise.SetResult(asset);
}
protected virtual IEnumerator DoDownloadFileAsync(string path, FileInfo fileInfo,
IProgressPromise <ProgressInfo> promise, float overtimeTime)
{
if (fileInfo.Directory != null && !fileInfo.Directory.Exists)
{
fileInfo.Directory.Create();
}
ProgressInfo progressInfo = new ProgressInfo {
TotalCount = 1
};
using (UnityWebRequest www = new UnityWebRequest(path))
{
var downloadFileHandler = new DownloadFileHandler(fileInfo);
www.downloadHandler = downloadFileHandler;
www.SendWebRequest();
float timer = 0;
while (!www.isDone)
{
if (www.downloadProgress >= 0)
{
if (progressInfo.TotalSize <= 0)
{
progressInfo.TotalSize = (long)(www.downloadedBytes / www.downloadProgress);
}
progressInfo.CompletedSize = (long)www.downloadedBytes;
promise.UpdateProgress(progressInfo);
}
timer += Time.deltaTime;
if (timer > overtimeTime)
{
promise.SetException(new TimeoutException());
break;
}
yield return(null);
}
while (!downloadFileHandler.WriteFinish)
{
timer += Time.deltaTime;
if (timer > overtimeTime)
{
promise.SetException(new TimeoutException());
break;
}
yield return(null);
}
if (www.isNetworkError || www.isHttpError)
{
promise.SetException(www.error);
yield break;
}
progressInfo.CompletedCount = 1;
progressInfo.CompletedSize = progressInfo.TotalSize;
promise.UpdateProgress(progressInfo);
promise.SetResult(fileInfo);
}
}
protected virtual IEnumerator DoLoadAllAssetsAsync <T>(IProgressPromise <float, T[]> promise) where T : Object
{
List <T> assets = new List <T>();
string[] fullNames = AssetDatabase.GetAssetPathsFromAssetBundle(this.GetBundleNameWhitExtension());
for (int i = 0; i < fullNames.Length; i++)
{
var fullName = fullNames[i];
promise.UpdateProgress((float)i / fullNames.Length);
if (fullName.EndsWith(".unity", System.StringComparison.OrdinalIgnoreCase))
{
continue;
}
Object[] array = AssetDatabase.LoadAllAssetRepresentationsAtPath(fullName);
foreach (Object asset in array)
{
if (asset != null && asset is T && !(asset is SceneAsset) && !(asset is DefaultAsset))
{
assets.Add((T)asset);
}
}
yield return(null);
}
promise.UpdateProgress(1f);
promise.SetResult(assets.ToArray());
}
protected virtual IEnumerator DoLoadAssetsToMapAsync <T>(IProgressPromise <float, Dictionary <string, T> > promise, params string[] names) where T : Object
{
if (names == null || names.Length <= 0)
{
promise.SetResult(new Object[0]);
yield break;
}
Dictionary <string, ResourceRequest> requests = new Dictionary <string, ResourceRequest>();
for (int i = 0; i < names.Length; i++)
{
var name = names[i];
if (requests.ContainsKey(name))
{
continue;
}
var fullName = this.GetFilePathWithoutExtension(name);
var request = Resources.LoadAsync <T>(fullName);
requests.Add(name, request);
}
int count = requests.Count;
float progress = 0f;
bool finished = false;
do
{
yield return(null);
finished = true;
progress = 0f;
foreach (ResourceRequest request in requests.Values)
{
if (!request.isDone)
{
finished = false;
}
progress += request.progress;
}
promise.UpdateProgress(progress / count);
} while (!finished);
Dictionary <string, T> assets = new Dictionary <string, T>();
foreach (var kv in requests)
{
var key = kv.Key;
var request = kv.Value;
T asset = (T)request.asset;
if (asset != null && !assets.ContainsKey(key))
{
assets.Add(key, asset);
}
}
promise.UpdateProgress(1f);
promise.SetResult(assets);
}
/// <summary>
/// Simulate a task.
/// </summary>
/// <returns>The task.</returns>
/// <param name="promise">Promise.</param>
protected IEnumerator DoTask(IProgressPromise <Progress, string> promise)
{
int n = 50;
Progress progress = new Progress();
progress.TotalBytes = n;
progress.bytes = 0;
StringBuilder buf = new StringBuilder();
for (int i = 0; i < n; i++)
{
/* If the task is cancelled, then stop the task */
if (promise.IsCancellationRequested)
{
promise.SetCancelled();
yield break;
}
progress.bytes += 1;
buf.Append(" ").Append(i);
promise.UpdateProgress(progress); /* update the progress of task. */
yield return(new WaitForSeconds(0.01f));
}
promise.SetResult(buf.ToString()); /* update the result. */
}
private IEnumerator CreateViewGo <T>(IProgressPromise <float, T> promise, View view, string path, ViewModel viewModel)
where T : View
{
var request = _res.LoadAssetAsync <GameObject>(path);
while (!request.IsDone)
{
promise.UpdateProgress(request.Progress);
yield return(null);
}
GameObject viewTemplateGo = request.Result;
if (viewTemplateGo == null)
{
promise.UpdateProgress(1f);
Log.Error($"Not found the window path = \"{path}\".");
promise.SetException(new FileNotFoundException(path));
yield break;
}
GameObject go = Object.Instantiate(viewTemplateGo);
view.SetGameObject(go);
go.name = viewTemplateGo.name;
promise.UpdateProgress(1f);
promise.SetResult(view);
view.SetVm(viewModel);
}
void Task4(IProgressPromise <float, string> promise)
{
Debug.Log("The task4 start");
int n = 10;
StringBuilder buf = new StringBuilder();
for (int i = 1; i <= n; i++)
{
/* If the task is cancelled, then stop the task */
if (promise.IsCancellationRequested)
{
promise.SetCancelled();
break;
}
buf.Append(i).Append(" ");
promise.UpdateProgress(i / (float)n);
#if NETFX_CORE
Task.Delay(100).Wait();
#else
Thread.Sleep(100);
#endif
}
promise.SetResult(buf.ToString()); /* set a result of the task */
Debug.Log("The task4 end");
}
protected virtual IEnumerator DoLoadAssetWithSubAssetsAsync <T>(IProgressPromise <float, T[]> promise, string name) where T : Object
{
string key = Key(name, typeof(T), "SubAssets");
AssetBundleRequest request;
if (!this.requestCache.TryGetValue(key, out request))
{
var fullName = GetFullName(name);
request = this.AssetBundle.LoadAssetWithSubAssetsAsync(fullName, typeof(T));
this.requestCache.Add(key, request);
}
while (!request.isDone)
{
promise.UpdateProgress(request.progress);
yield return(null);
}
this.requestCache.Remove(key);
var all = request.allAssets;
T[] assets = new T[all.Length];
for (int i = 0; i < all.Length; i++)
{
assets[i] = ((T)all[i]);
}
promise.UpdateProgress(1f);
promise.SetResult(assets);
}
protected virtual IEnumerator DoLoadAssetsToMapAsync <T>(IProgressPromise <float, Dictionary <string, T> > promise, params string[] names) where T : Object
{
Dictionary <string, T> results = new Dictionary <string, T>();
int count = names.Length;
float progress = 0f;
for (int i = 0; i < count; i++)
{
var name = names[i];
var fullName = GetFullName(name);
AssetBundleRequest request = this.assetBundle.LoadAssetAsync <T>(fullName);
while (!request.isDone)
{
promise.UpdateProgress(progress + request.progress / count);
yield return(null);
}
progress += 1f / count;
T asset = (T)request.asset;
if (asset != null && !results.ContainsKey(name))
{
results.Add(name, asset);
}
}
promise.UpdateProgress(1f);
promise.SetResult(results);
}
protected virtual IEnumerator DoLoadAssetsAsync(IProgressPromise <float, Object[]> promise, System.Type type, params string[] names)
{
if (names == null || names.Length <= 0)
{
promise.SetResult(new Object[0]);
yield break;
}
Dictionary <string, ResourceRequest> requests = new Dictionary <string, ResourceRequest>();
foreach (string name in names)
{
var fullName = this.GetFilePathWithoutExtension(name);
if (requests.ContainsKey(fullName))
{
continue;
}
var request = Resources.LoadAsync(fullName, type);
requests.Add(fullName, request);
}
int count = requests.Count;
float progress = 0f;
bool finished = false;
do
{
yield return(null);
finished = true;
progress = 0f;
foreach (ResourceRequest request in requests.Values)
{
if (!request.isDone)
{
finished = false;
}
progress += request.progress;
}
promise.UpdateProgress(progress / count);
} while (!finished);
List <Object> assets = new List <Object>();
foreach (ResourceRequest request in requests.Values)
{
Object asset = request.asset;
if (asset != null)
{
assets.Add(asset);
}
}
promise.UpdateProgress(1f);
promise.SetResult(assets.ToArray());
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
this.loader = null;
this.result = null;
this.routine = null;
this.disposed = true;
}
}
protected virtual IEnumerator DoLoad <T>(IProgressPromise <float, T> promise, string name)
{
name = Normalize(name);
WeakReference weakRef;
GameObject viewTemplateGo = null;
try
{
if (this.templates.TryGetValue(name, out weakRef) && weakRef.IsAlive)
{
viewTemplateGo = (GameObject)weakRef.Target;
//Check if the object is valid because it may have been destroyed.
//Unmanaged objects,the weak caches do not accurately track the validity of objects.
if (viewTemplateGo != null)
{
string goName = viewTemplateGo.name;
}
}
}
catch (Exception)
{
viewTemplateGo = null;
}
if (viewTemplateGo == null)
{
ResourceRequest request = Resources.LoadAsync <GameObject>(name);
while (!request.isDone)
{
promise.UpdateProgress(request.progress);
yield return(null);
}
viewTemplateGo = (GameObject)request.asset;
if (viewTemplateGo != null)
{
viewTemplateGo.SetActive(false);
this.templates[name] = new WeakReference(viewTemplateGo);
}
}
if (viewTemplateGo == null || viewTemplateGo.GetComponent <T>() == null)
{
promise.UpdateProgress(1f);
promise.SetException(new NotFoundException(name));
yield break;
}
GameObject go = GameObject.Instantiate(viewTemplateGo);
go.name = viewTemplateGo.name;
promise.UpdateProgress(1f);
promise.SetResult(go.GetComponent <T>());
}
protected override IEnumerator DoLoadAssetBundle(IProgressPromise <float, AssetBundle> promise)
{
#if UNITY_2018_1_OR_NEWER
if (this.decryptor.AlgorithmName.Equals("AES128_CTR_NONE") && !FileUtil.IsZipArchive(this.GetAbsolutePath()))
{
return(DoLoadAssetBundleFromStream(promise));
}
#endif
return(DoLoadAssetBundleFromMemory(promise));
}
/// <summary>
/// Simulate a task.
/// </summary>
/// <returns>The task.</returns>
/// <param name="promise">Promise.</param>
protected IEnumerator DoTask(IProgressPromise <float, bool> promise)
{
int n = 50;
for (int i = 0; i < n; i++)
{
promise.UpdateProgress((float)i / n);
yield return(new WaitForSeconds(0.1f));
}
promise.SetResult(true);
}
private async void instantiateAsync(AsyncOperationHandle <GameObject> operation,
IProgressPromise <float, GameObject> promise)
{
_handles.Add(operation);
while (!operation.IsDone)
{
promise.UpdateProgress(operation.PercentComplete);
await Task.Yield();
}
promise.UpdateProgress(1);
promise.SetResult(operation.Result);
}
private IEnumerator DoLoadGameScene(IProgressPromise <float> progressPromise)
{
AsyncOperation asyncOperation = SceneManager.LoadSceneAsync("GameScene");
while (!asyncOperation.isDone)
{
progressPromise.UpdateProgress(asyncOperation.progress);
yield return(null);
}
progressPromise.UpdateProgress(1f);
progressPromise.SetResult();
}
/// <summary>
/// run on the background thread.
/// </summary>
/// <param name="promise">Promise.</param>
protected void DoUnzip(IProgressPromise <float> promise)
{
var progress = 0f;
while (progress < 1f)
{
progress += 0.01f;
promise.UpdateProgress(progress);
//Thread.Sleep (50);
Thread.Sleep(30);
}
promise.SetResult();
}
protected override async void loadAssetAsync <T>(string key, IProgressPromise <float, T> promise)
{
var operation = Resources.LoadAsync <T>(key);
while (!operation.isDone)
{
promise.UpdateProgress(operation.progress);
await Task.Yield();
}
promise.UpdateProgress(1);
promise.SetResult(operation.asset as T);
_handles.Add(operation.asset);
}
protected override async void LoadScene(IProgressPromise <float, Scene> promise, string path, LoadSceneMode loadSceneMode)
{
var loader = Addressables.LoadSceneAsync(path, loadSceneMode);
while (!loader.IsDone)
{
await Task.Yield();
promise.UpdateProgress(loader.PercentComplete);
}
promise.UpdateProgress(1);
promise.SetResult(loader.Result.Scene);
}
protected override async void LoadScene(IProgressPromise <float, string> promise, string path, LoadSceneMode loadSceneMode, bool allowSceneActivation = true)
{
var operation = SceneManager.LoadSceneAsync(path, loadSceneMode);
operation.allowSceneActivation = allowSceneActivation;
var waitEnd = new WaitForEndOfFrame();
while (!operation.isDone)
{
await waitEnd;
promise.UpdateProgress(operation.progress);
}
promise.SetResult(Path.GetFileNameWithoutExtension(path));
}
private IEnumerator loadAsync <T>(string key, IProgressPromise <float, T> promise) where T : Object
{
var operation = Resources.LoadAsync <T>(key);
requests.Add(operation);
while (!operation.isDone)
{
promise.UpdateProgress(operation.progress);
yield return(null);
}
promise.UpdateProgress(1);
promise.SetResult(operation.asset as T);
_handles.Add(operation.asset);
}
protected virtual IEnumerator DoLoadAllAssetsAsync <T>(IProgressPromise <float, T[]> promise) where T : Object
{
try
{
T[] assets = Resources.LoadAll <T>(this.Root);
promise.UpdateProgress(1f);
promise.SetResult(assets);
}
catch (System.Exception e)
{
promise.UpdateProgress(0f);
promise.SetException(e);
}
yield break;
}
protected virtual IEnumerator DoLoadAllAssetsAsync(IProgressPromise <float, Object[]> promise, System.Type type)
{
try
{
Object[] assets = Resources.LoadAll(this.Root);
promise.UpdateProgress(1f);
promise.SetResult(assets);
}
catch (System.Exception e)
{
promise.UpdateProgress(0f);
promise.SetException(e);
}
yield break;
}
static IEnumerator Download(IProgressPromise <float> promise, AsyncOperationHandle handle)
{
while (!handle.IsDone)
{
promise.UpdateProgress(handle.PercentComplete);
yield return(null);
if (handle.OperationException != null)
{
promise.SetException(handle.OperationException);
}
}
promise.SetException(handle.OperationException);
promise.SetResult();
}
/// <summary>
/// run on the main thread.
/// </summary>
/// <returns>The check.</returns>
/// <param name="promise">Promise.</param>
protected IEnumerator DoLoadScene(IProgressPromise <float> promise)
{
ResourceRequest request = Resources.LoadAsync <GameObject> ("Scenes/Jungle");
while (!request.isDone)
{
promise.UpdateProgress(request.progress);
yield return(null);
}
GameObject sceneTemplate = (GameObject)request.asset;
GameObject.Instantiate(sceneTemplate);
promise.UpdateProgress(1f);
promise.SetResult();
}
/// <summary>
/// Simulate a task.
/// </summary>
/// <returns>The task.</returns>
/// <param name="promise">Promise.</param>
protected IEnumerator DoTask(IProgressPromise <float, bool> promise)
{
int n = 50;
for (int i = 0; i < n; i++)
{
promise.UpdateProgress((float)i / n);
yield return(new WaitForSeconds(0.1f));
if (i == 20)
{
throw new System.Exception("This is a test, not a bug.");
}
}
promise.SetResult(true);
}
