/// <summary>
/// Clear contents
/// </summary>
// -------------------------------------------------------------------------------------------------------
protected void clearContents()
{
this.m_loadingScenesProgress.Clear();
this.m_commonUiIdentifiersAfterLoadingScene.Clear();
this.m_sceneUiIdentifiersAfterLoadingScene.Clear();
this.m_resumePoint = ResumePoint.None;
IEnumeratorStartupManager.Instance.clearContents();
WwwStartupManager.Instance.clearContents();
AssetBundleStartupManager.Instance.clearContents();
this.m_loopCounterForABStartup = 0;
}
public async Task GetMethodReturnsCorrectInstance()
{
const string accountId = "123";
const string videoId = "456";
const double timePoint = 12.3;
ResumePoint expected = new ResumePoint()
{
AccountId = accountId,
VideoId = videoId,
TimePoint = timePoint
};
var mock = new Mock <IResumePointRepository>();
mock.Setup(repo => repo.Get(accountId, videoId)).Returns(Task.FromResult(expected));
AccountsVideoController controller = new AccountsVideoController(mock.Object);
ResumePoint actual = await controller.GetResumePointForVideo(accountId, videoId);
Assert.AreEqual(expected, actual);
}
public async Task <ResumePoint> GetResumePointForVideo(string accountId, string videoId)
{
ResumePoint resumePoint = await this.resumePointRepository.Get(accountId, videoId);
return(resumePoint);
}
// -------------------------------------------------------------------------------------------------------
protected IEnumerator startNowLoadings(ResumePoint resumePoint)
{
yield return(null);
// wait by lock
{
int i = 0;
while (this.m_lockBeforeLoadings.Count > 0)
{
yield return(null);
for (i = this.m_lockBeforeLoadings.Count - 1; i >= 0; i--)
{
if (!this.m_lockBeforeLoadings[i])
{
this.m_lockBeforeLoadings.RemoveAt(i);
}
}
}
}
// unload
if (resumePoint == ResumePoint.None)
{
AsyncOperation ao = Resources.UnloadUnusedAssets();
while (!ao.isDone)
{
yield return(null);
}
System.GC.Collect();
}
// SceneChangeStateWatcher
{
if (resumePoint == ResumePoint.None)
{
var scState = SimpleReduxManager.Instance.SceneChangeStateWatcher.state();
scState.setState(SimpleReduxManager.Instance.SceneChangeStateWatcher, SceneChangeState.StateEnum.NowLoadingMain);
}
}
// load
if (resumePoint == ResumePoint.None)
{
if (!this.m_loadingScenesProgress.ContainsKey(this.m_nowLoadingSceneName))
{
this.m_loadingScenesProgress.Add(this.m_nowLoadingSceneName, 0.0f);
}
AsyncOperation ao = SceneManager.LoadSceneAsync(this.m_nowLoadingSceneName);
if (ao == null)
{
Invoke("showBackToTitleOkDialog", 0.1f);
yield break;
}
while (!ao.isDone)
{
this.m_loadingScenesProgress[this.m_nowLoadingSceneName] = ao.progress;
yield return(null);
}
this.m_loadingScenesProgress[this.m_nowLoadingSceneName] = 1.0f;
}
// main
{
bool sceneAdditiveDetected = false;
bool needToReload = false;
System.Object messages = null;
do
{
sceneAdditiveDetected = false;
// IEnumeratorStartupManager Before
if (resumePoint <= ResumePoint.IEBefore)
{
yield return(IEnumeratorStartupManager.Instance.startIEnumerator(IEnumeratorStartupManager.BeforeAfter.Before));
if (IEnumeratorStartupManager.Instance.hasError())
{
messages = IEnumeratorStartupManager.Instance.createErrorMessage();
this.m_resumePoint = ResumePoint.IEBefore;
break;
}
}
// AssetBundleStartupManager
if (resumePoint <= ResumePoint.AssetBundle)
{
List <AssetBundle> additiveScenes = new List <AssetBundle>();
yield return(AssetBundleStartupManager.Instance.startAbStartup(
this.m_loopCounterForABStartup++ > 0,
(detectedAdditiveScenes) =>
{
additiveScenes.AddRange(detectedAdditiveScenes);
},
(reload) =>
{
needToReload = reload;
}));
if (AssetBundleStartupManager.Instance.hasError())
{
messages = AssetBundleStartupManager.Instance.createErrorMessage();
this.m_resumePoint = ResumePoint.AssetBundle;
break;
}
if (needToReload)
{
break;
}
if (additiveScenes.Count > 0)
{
sceneAdditiveDetected = true;
for (int i = additiveScenes.Count - 1; i >= 0; i--)
{
AssetBundle ab = additiveScenes[i];
foreach (string str in ab.GetAllScenePaths())
{
if (!this.m_loadingScenesProgress.ContainsKey(str))
{
this.m_loadingScenesProgress.Add(str, 0.0f);
}
var aoForAdditive = SceneManager.LoadSceneAsync(Path.GetFileNameWithoutExtension(str), LoadSceneMode.Additive);
while (!aoForAdditive.isDone)
{
this.m_loadingScenesProgress[str] = aoForAdditive.progress;
yield return(null);
}
this.m_loadingScenesProgress[str] = 1.0f;
}
ab.Unload(false);
}
continue;
}
}
// WwwStartupManager
if (resumePoint <= ResumePoint.Www)
{
yield return(WwwStartupManager.Instance.startWwwStartup());
if (WwwStartupManager.Instance.hasError())
{
messages = WwwStartupManager.Instance.createErrorMessage();
this.m_resumePoint = ResumePoint.Www;
break;
}
}
// IEnumeratorStartupManager After
if (resumePoint <= ResumePoint.IEAfter)
{
yield return(IEnumeratorStartupManager.Instance.startIEnumerator(IEnumeratorStartupManager.BeforeAfter.After));
if (IEnumeratorStartupManager.Instance.hasError())
{
messages = IEnumeratorStartupManager.Instance.createErrorMessage();
this.m_resumePoint = ResumePoint.IEAfter;
break;
}
}
} while (sceneAdditiveDetected);
if (messages != null)
{
DialogManager.Instance.showYesNoDialog(messages, this.retry, this.showBackToTitleOkDialog);
yield break;
}
if (needToReload)
{
Invoke("callbackWhenShowingNowLoadingDone", 0.1f);
yield break;
}
//
{
if (IEnumeratorStartupManager.Instance.checkIfDetectedNewStartup(IEnumeratorStartupManager.BeforeAfter.Before))
{
this.m_resumePoint = ResumePoint.IEBefore;
Invoke("retry", 0.1f);
yield break;
}
else if (AssetBundleStartupManager.Instance.checkIfDetectedNewStartup())
{
this.m_resumePoint = ResumePoint.AssetBundle;
Invoke("retry", 0.1f);
yield break;
}
else if (WwwStartupManager.Instance.checkIfDetectedNewStartup())
{
this.m_resumePoint = ResumePoint.Www;
Invoke("retry", 0.1f);
yield break;
}
else if (IEnumeratorStartupManager.Instance.checkIfDetectedNewStartup(IEnumeratorStartupManager.BeforeAfter.After))
{
this.m_resumePoint = ResumePoint.IEAfter;
Invoke("retry", 0.1f);
yield break;
}
}
}
// SceneChangeStateWatcher
{
yield return(null);
var scState = SimpleReduxManager.Instance.SceneChangeStateWatcher.state();
scState.setState(SimpleReduxManager.Instance.SceneChangeStateWatcher, SceneChangeState.StateEnum.AllStartupsDone);
yield return(null);
}
// wait by lock
{
int i = 0;
while (this.m_lockAfterLoadings.Count > 0)
{
yield return(null);
for (i = this.m_lockAfterLoadings.Count - 1; i >= 0; i--)
{
if (!this.m_lockAfterLoadings[i])
{
this.m_lockAfterLoadings.RemoveAt(i);
}
}
}
}
// SceneChangeStateWatcher
{
var scState = SimpleReduxManager.Instance.SceneChangeStateWatcher.state();
scState.setState(SimpleReduxManager.Instance.SceneChangeStateWatcher, SceneChangeState.StateEnum.NowLoadingOutro);
}
// show ui
{
if (SceneUiManager.isAvailable())
{
if (this.m_sceneUiIdentifiersAfterLoadingScene.Count > 0)
{
SceneUiManager.Instance.showUi(this.m_sceneUiIdentifiersAfterLoadingScene, true, false, 0, null, null);
}
CommonUiManager.Instance.showUi(this.m_commonUiIdentifiersAfterLoadingScene, true, false, 0, this.sendNowLoadingDoneSignal, null);
}
else
{
CommonUiManager.Instance.showUi(this.m_commonUiIdentifiersAfterLoadingScene, true, false, 0, this.sendNowLoadingDoneSignal, null);
}
}
// clear
{
this.clearContents();
}
}
