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();
}
