public override void Unload(ISceneStrategy sceneStrategy)
{
if (!HasSceneStrategy(sceneStrategy.SceneName))
{
throw new ArgumentOutOfRangeException($"Does not find `{sceneStrategy.SceneName}' in SceneStrategyMap.");
}
if (HasPostUnloadSceneStrategy(sceneStrategy.SceneName))
{
// First, unload target scene
UnloadAsObservable(sceneStrategy)
.ForEachAsync(
_ => SceneStrategyMap[sceneStrategy.SceneName]
.PostUnloadSceneNameList
.ToList()
.ForEach(DecrementReferenceCounter)
)
.ObserveOnMainThread()
// Second, unload post unload scenes
.SelectMany(
_ => SceneStrategyMap[sceneStrategy.SceneName]
.PostUnloadSceneNameList
.Where(x => !ReferenceCounterMap.ContainsKey(x) || ReferenceCounterMap[x] <= 0)
.Select(x => SceneStrategyMap[x])
.Where(x => !x.ProtectFromUnloading)
.Select(UnloadAsObservable)
.WhenAll()
)
.Subscribe();
}
else
{
UnloadAsObservable(sceneStrategy).Subscribe();
}
}
protected bool CanLoadScene(ISceneStrategy sceneStrategy)
{
if (sceneStrategy.CanLoadMultiple)
{
return(true);
}
return(!HasLoaded(sceneStrategy) && (!LoadDisposableMap.ContainsKey(sceneStrategy.SceneName) || LoadDisposableMap[sceneStrategy.SceneName] == null));
}
protected IObservable <Unit> UnloadAsObservable(ISceneStrategy sceneStrategy)
{
if (SceneEntityList.All(x => x.SceneStrategy.SceneName != sceneStrategy.SceneName))
{
return(Observable.Throw <Unit>(new ArgumentOutOfRangeException($"Scene name `{sceneStrategy.SceneName}' does not contain in loaded scenes.")));
}
SceneStateEntity.WillUnloadSubject.OnNext(sceneStrategy.SceneName);
// Search from last
var sceneEntity = SceneEntityList.Last(x => x.SceneStrategy.SceneName == sceneStrategy.SceneName);
return(sceneEntity
.Unload()
.ToObservable()
.ForEachAsync(_ => SceneEntityList.Remove(sceneEntity)));
}
protected IObservable <Unit> LoadAsObservable(ISceneStrategy sceneStrategy)
{
// Do nothing if duplicate loading
if (!CanLoadScene(sceneStrategy))
{
return(Observable.ReturnUnit());
}
var sceneEntity = SceneEntityFactory.Create(sceneStrategy);
// For blocking when a Load instruction flew in the same frame
LoadDisposableMap[sceneStrategy.SceneName] = sceneEntity.DidLoadAsObservable().Take(1).Subscribe();
SceneEntityList.AddLast(sceneEntity);
SceneStateEntity.WillLoadSubject.OnNext(sceneEntity.SceneStrategy.SceneName);
return(SceneRepository
.GetAsync(sceneStrategy)
.ToObservable()
.SelectMany(
_ => sceneEntity
.Load()
.ToObservable()
)
.ForEachAsync(_ => LoadDisposableMap.Remove(sceneStrategy.SceneName)));
}
public override void Load(ISceneStrategy sceneStrategy)
{
if (!HasSceneStrategy(sceneStrategy.SceneName))
{
throw new ArgumentOutOfRangeException($"Does not find `{sceneStrategy.SceneName}' in SceneStrategyMap.");
}
if (!CanLoadScene(sceneStrategy))
{
return;
}
if (HasPreLoadSceneStrategy(sceneStrategy.SceneName))
{
// First, load pre load scenes
SceneStrategyMap[sceneStrategy.SceneName]
.PreLoadSceneNameList
.Select(x => SceneStrategyMap[x])
.Select(LoadAsObservable)
.WhenAll()
.ForEachAsync(
_ => SceneStrategyMap[sceneStrategy.SceneName]
.PreLoadSceneNameList
.ToList()
.ForEach(IncrementReferenceCounter)
)
.ObserveOnMainThread()
// Second, load target scene
.SelectMany(_ => LoadAsObservable(sceneStrategy))
.Subscribe();
}
else
{
LoadAsObservable(sceneStrategy).Subscribe();
}
}
public abstract void Unload(ISceneStrategy sceneStrategy);
private bool HasLoaded(ISceneStrategy sceneStrategy)
{
return(RequestEntity.HasLoaded(sceneStrategy.SceneName));
}
public async Task <IScene> GetAsync(ISceneStrategy sceneStrategy)
{
return(await Task.FromResult(SceneStructureFactory.Create(sceneStrategy.SceneName)));
}
public async Task <IScene> GetAsync(ISceneStrategy sceneStrategy)
{
return(await SceneDataStoreResolver.Resolve(sceneStrategy).GetAsync(sceneStrategy));
}
public SceneEntity(ISceneStrategy sceneStrategy)
{
SceneStrategy = sceneStrategy;
}
public override void Load(ISceneStrategy sceneStrategy)
{
LoadAsObservable(sceneStrategy).Subscribe();
}
public Task <IScene> GetAsync(ISceneStrategy sceneStrategy)
{
throw new NotImplementedException();
}
