static void SetActiveWithDelay(bool value, float delay) { var inst = LoadingIndicator.instance; if (!inst) { return; } if (value == inst.activate) { return; } if (value && 0 < delay) { if (0 == inst.waitForDelay) { inst.waitForDelay = delay; var gen = inst.generation; var signal = new CancellableSignal(() => !inst || gen != inst.generation || inst.IsDone); CoroutineTaskManager.AddTask(inst.OnActiveWithDelay(signal, delay, Time.realtimeSinceStartup)); } else { inst.waitForDelay = Mathf.Min(inst.waitForDelay, delay); } } else { inst.OnActive(value); } }
IEnumerator OnOpenSheets(CancellableSignal signal) { var subTaskHandle = new SubTaskHandle(signal); var enumerator = ServiceModelManager.OpenSheetTask(subTaskHandle); while (enumerator.MoveNext()) { this.SetSubProgress(subTaskHandle.Progress); yield return(enumerator.Current); if (CancellableSignal.IsCancelled(signal)) { yield break; } } if (subTaskHandle.IsError) { #if LOG_DEBUG Debug.LogWarning(string.Format("ASSET:EXCEPT:SHEETS:EXCEPT:{0}", subTaskHandle.Except)); #endif// LOG_DEBUG var e = subTaskHandle.Except; this.SetFailed(signal, 'S', e.GetType().Name, e.Message); yield break; } this.SetSubProgress(1); yield return(null); if (CancellableSignal.IsCancelled(signal)) { yield break; } }
static IEnumerator OnLoadAsync(CancellableSignal signal, ResourceRequest req, string path, string popName, bool foremost, Action <Popup> loadDoneCallback) { yield return(req); if (CancellableSignal.IsCancelled(signal)) { yield break; } var prefab = req.asset as Popup; var pop = Popup.OnLoaded(prefab, path, popName, foremost, false); if (null != loadDoneCallback) { loadDoneCallback(pop); } }
internal void SetFailed(CancellableSignal signal, char stateInitial, string errLog, string errLogDetail) { this.state = State.Except; this.stateErrLog = string.Format("{0}:{1}", stateInitial, errLog); this.stateDetailErrLog = string.Format("{0}:{1}", stateInitial, errLogDetail); CancellableSignal.Cancel(signal); }
internal void Start() { this.Stop(); this.stateErrLog = ""; this.signal = new CancellableSignal(); this.coroutine = CoroutineTaskManager.AddTask(this.OnStart(this.signal)); }
IEnumerator OnStart(CancellableSignal signal) { for (State state = State.None, cnt = State.Done; state < cnt; ++state) { var enumerator = this.SetState(state, signal); if (null == enumerator) { continue; } while (enumerator.MoveNext()) { yield return(enumerator.Current); if (CancellableSignal.IsCancelled(signal)) { yield break; } } if (CancellableSignal.IsCancelled(signal)) { yield break; } } // NOTE: last action if (this.progressEnd > this.progress) { int lastFrameCount = (int)Mathf.Lerp(30, 15, this.progress); // (0.5 ~ 0.25) + @ sec float dt = 1 / (float)lastFrameCount; for (int n = 0; n < lastFrameCount; ++n) { this.SetSubProgress(dt * n); yield return(null); if (CancellableSignal.IsCancelled(signal)) { yield break; } } } this.SetSubProgress(1); yield return(null); if (CancellableSignal.IsCancelled(signal)) { yield break; } if (State.Except != this.state) { this.state = State.Done; } this.coroutine = null; }
IEnumerator OnOpenServiceTask(Asset.SubTaskHandle sth, Action loadStart, Func <bool> loadDone = null) { var signal = sth.Signal; if (CancellableSignal.IsCancelled(signal)) { yield break; } try { loadStart(); } catch (Exception e) { Debug.LogWarning(string.Format("SERVICEMODEL:WARN:OPEN_SERVICE_EXCEPT:{0}", e)); sth.SetFailed(e); yield break; } if (null != loadDone) { bool isDone = false; do { try { isDone = loadDone(); } catch (Exception e) { Debug.LogWarning(string.Format("SERVICEMODEL:WARN:OPEN_SERVICE_EXCEPT#2:{0}", e)); sth.SetFailed(e); yield break; } yield return(null); if (CancellableSignal.IsCancelled(signal)) { yield break; } }while (!isDone); } else { yield return(null); if (CancellableSignal.IsCancelled(signal)) { yield break; } } sth.Complete(); }
public static void ResetSignal(CancellableSignal value) { if (null != ViewAsync.signal) { CancellableSignal.Cancel(ViewAsync.signal); } ViewAsync.signal = value; }
internal IEnumerator OpenSheetTask(Asset.SubTaskHandle sth) { var signal = sth.Signal; if (CancellableSignal.IsCancelled(signal)) { yield break; } var sheetInfos = new SheetInfo[] { //this.CreateSheetInfo<long, GameConfigData >(this.OnOpenSheets_GameConfigData ), //this.CreateSheetInfo<long, RegionData >(this.OnOpenSheets_RegionData ), //this.CreateSheetInfo<long, ComposerData >(this.OnOpenSheets_ComposerData ), //this.CreateSheetInfo<long, MusicData >(this.OnOpenSheets_MusicData ), //this.CreateSheetInfo<long, BgmData >(this.OnOpenSheets_BgmData ), //this.CreateSheetInfo<long, MatineeData >(this.OnOpenSheets_MatineeData ), //this.CreateSheetInfo<long, StarData >(this.OnOpenSheets_StarData ), //this.CreateSheetInfo<long, JudgementData >(this.OnOpenSheets_JudgementData ), //this.CreateSheetInfo<long, Concours4KeyData >(this.OnOpenSheets_Concours4KeyData ), //this.CreateSheetInfo<long, Concours6KeyData >(this.OnOpenSheets_Concours6KeyData ), //this.CreateSheetInfo<long, PianoData >(this.OnOpenSheets_PianoData ), this.CreateSheetInfo <long, UnitData>(this.OnOpenSheets_UnitData), }; var progressStride = 1f / sheetInfos.Length; var progressStrideHalf = progressStride * 0.5f; var progress = 0f; for (int n = 0, cnt = sheetInfos.Length; n < cnt; ++n) { var si = sheetInfos[n]; var source = Resources.Load <TextAsset>(string.Format("Data/{0}", si.sheetname)); if (!source) { Debug.LogError(string.Format("SERVICEMODEL:SHEET_NOT_FOUND_ERROR:{0}", si.sheetname)); } sth.SetProgress(progress + progressStrideHalf); yield return(null); if (CancellableSignal.IsCancelled(signal)) { yield break; } si.parseFunc(si, source); sth.SetProgress(progress += progressStride); yield return(null); if (CancellableSignal.IsCancelled(signal)) { yield break; } } sth.Complete(); }
public static ResourceRequest LoadAsync(CancellableSignal signal, string popName, bool foremost = false, Action <Popup> loadDoneCallback = null) { if (Popup.testMode) { if (null != loadDoneCallback) { loadDoneCallback(null); } return(null); } #if LOG_DEBUG Debug.Log("POPUP_LOAD_ASYNC:" + popName); #endif// LOG_DEBUG if (!PopupRoot.Instance) { #if LOG_DEBUG Debug.Log("POPUP_LOAD_ASYNC_FAILED:" + popName + ", ROOT_IS_NULL"); #endif// LOG_DEBUG return(null); } var popRecycle = Popup.CancelDestroyWithRecycle(popName); if (popRecycle) { if (null != loadDoneCallback) { loadDoneCallback(popRecycle); } return(null); } Popup.sbPath.Length = Popup.basePath.Length; Popup.sbPath.Append(popName); string path = Popup.sbPath.ToString(); var req = Resources.LoadAsync <Popup>(path); if (null == req) { #if LOG_DEBUG Debug.Log("POPUP_LOAD_ASYNC_FAILED:" + popName + ", PATH:" + path + ", RESOURCES_LOAD_FAILED"); #endif// LOG_DEBUG return(null); } CoroutineTaskManager.AddTask(Popup.OnLoadAsync(signal, req, path, popName, foremost, loadDoneCallback)); return(req); }
internal void Stop() { CancellableSignal.Cancel(this.signal); this.signal = null; if (this.coroutine != null) { CoroutineTaskManager.RemoveTask(this.coroutine); this.coroutine = null; } }
public static Handler Start(ICollection <Task> tasks, TArgument argument, Action <Handler> doneCallback = null, CancellableSignal overrideSignal = null) { var coHandle = new Handler(tasks, argument, doneCallback, overrideSignal); CoroutineTaskManager.AddTask(CoroutinePipeline <TArgument> .MainTask(coHandle)); return(coHandle); }
IEnumerator Routine(UnityAsyncHandler.Input input, SubRoutine[] subRoutines) { float subProgressTerm = 1 / (float)subRoutines.Length; IEnumerator enumerator; SubRoutineOutput subOutput = new SubRoutineOutput(); for (int n = 0, count = subRoutines.Length; n < count; ++n) { subOutput.outSubProgress = 0; this.SetSubProgressRange(this.Progress + subProgressTerm); SubRoutine subRoutine = subRoutines[n]; enumerator = subRoutine(input, this.Out, subOutput); while (enumerator.MoveNext()) { this.SetSubProgress(subOutput.outSubProgress); this.Update(); yield return(enumerator.Current); if (CancellableSignal.IsCancelled(input.signal)) { if (!this.IsCanceled) { this.Cancel(); } this.OnCancelDone(); yield break; } } this.SetSubProgress(1); this.Update(); yield return(null); if (CancellableSignal.IsCancelled(input.signal)) { if (!this.IsCanceled) { this.Cancel(); } this.OnCancelDone(); yield break; } } this.Done(); yield return(null); }
IEnumerator OnOpenServiceModels(CancellableSignal signal) { var subTaskHandle = new SubTaskHandle(signal); var tasks = ServiceModelManager.OpenServiceTask(subTaskHandle); int count = tasks.Length; float progress = 0f; float progressDelta = 1 / (float)count; foreach (var task in tasks) { subTaskHandle.Clear(); while (task.MoveNext()) { this.SetSubProgress(progress + (progressDelta * subTaskHandle.Progress)); yield return(task.Current); if (CancellableSignal.IsCancelled(signal)) { yield break; } } progress += progressDelta; this.SetSubProgress(progress); if (subTaskHandle.IsError) { #if LOG_DEBUG Debug.LogWarning("ASSET:EXCEPT:SERVICE_MODELS"); #endif// LOG_DEBUG var e = subTaskHandle.Except; this.SetFailed(signal, 'C', e.GetType().Name, e.Message); yield break; } } this.SetSubProgress(1); yield return(null); if (CancellableSignal.IsCancelled(signal)) { yield break; } }
public Handler(ICollection <Task> tasks, TArgument arg, Action <Handler> doneCallback, CancellableSignal overrideSignal) { this.tasks = new Task[tasks.Count]; int n = 0; foreach (var task in tasks) { this.tasks[n++] = task; } this.arg = arg; this.doneCallback = doneCallback; this.signal = null != overrideSignal ? overrideSignal : new CancellableSignal(); }
IEnumerator SetState(State state, CancellableSignal signal) { this.state = state; int index = (int)state; if (-1 < index && index < this.stateMgrs.Length) { var sd = this.stateMgrs[index]; if (null != sd) { this.SetProgressRange(sd.progress); if (null != sd.func) { return(sd.func(signal)); } } } return(null); }
IEnumerator OnActiveWithDelay(CancellableSignal signal, float delay, float prev) { do { yield return(null); if (CancellableSignal.IsCancelled(signal)) { this.waitForDelay = 0; //Debug.Log("CANCEL"); yield break; } var now = Time.realtimeSinceStartup; var delta = now - prev; //var old = this.waitForDelay; this.waitForDelay = Mathf.Max(0, this.waitForDelay - delta); //Debug.Log("DELAY:" + this.waitForDelay + ", OLD:" + old + ", DT:" + delta + ", PREV:" + prev + ", NOW:" + now); prev = now; }while (0 < this.waitForDelay); this.OnActive(true); }
public void Cancel() { CancellableSignal.Cancel(this.signal); }
internal SubTaskHandle(CancellableSignal signal, object implData = null) { this.signal = signal; this.inData = implData; this.Clear(); }