private void OnDisable()
{
disposables?.Clear();
control.Opened -= OpenShop;
control.Closed -= CloseShop;
shop.BuildingSelected -= OnBuildingSelected;
selector.Placed -= OnPlaced;
constructor.Constructed -= OnConstructed;
}
public void Clear()
{
var d = new CompositeDisposable (Disposable.Empty);
Assert.AreEqual (1, d.Count, "#1");
d.Clear ();
Assert.AreEqual (0, d.Count, "#2");
}
void CreateOrReuseView(IConnection connection, ViewWithData data, Action <IView> onViewLoad)
{
IUIController controller;
var exists = reusableControllers.TryGetValue(data.MainFlow, out controller);
if (!exists)
{
IsBusy = true;
Action <IView> handler = view =>
{
disposablesForCurrentView?.Clear();
var action = view.ViewModel as ICanNavigate;
if (action != null)
{
disposablesForCurrentView.Add(action?.Navigate.Subscribe(d =>
{
LoadView(connection, d, onViewLoad);
}));
}
onViewLoad?.Invoke(view);
};
controller = CreateController(connection, data, handler);
reusableControllers.Add(data.MainFlow, controller);
}
Push(controller);
if (exists)
{
Reload();
}
}
public override void OnRemove()
{
showLevelCompleteSignal.RemoveListener(OnShow);
hideLevelCompleteSignal.RemoveListener(OnHide);
_subscriptions?.Clear();
}
public override void OnRemove()
{
showMenuSignal.RemoveListener(OnShow);
hideMenuSignal.RemoveListener(OnHide);
_subscriptions?.Clear();
}
private void Clear()
{
view.TimerText = String.Empty;
view.StarComponent.Stars = 0;
view.CollectedText = "0/0";
view.TopPanelPool.ReleaseAllInstances();
view.GameFieldPool.ReleaseAllInstances();
view.AnimatedPool.ReleaseAllInstances();
_subscriptions?.Clear();
_animatedItems.Clear();
foreach (var sequence in _sequences)
{
sequence.Kill();
}
_sequences.Clear();
}
void TerminateShell()
{
rePoolingSubs.Clear();
GameObjectPooler.Current.PoolObject(this.gameObject);
}
public void Dispose()
{
disposables.Clear();
}
public override void OnEnable()
{
base.OnEnable();
contentSwitchComponents.OnAdd().Subscribe(entity =>
{
var contentSwitchComponent = entity.GetComponent <ContentSwitchComponent>();
var viewComponent = entity.GetComponent <ViewComponent>();
var rectTransform = viewComponent.Transforms[0] as RectTransform;
var width = Display.displays[Mathf.Clamp(contentSwitchComponent.TargetDisplay, 0, Display.displays.Length - 1)].renderingWidth;
var height = Display.displays[Mathf.Clamp(contentSwitchComponent.TargetDisplay, 0, Display.displays.Length - 1)].renderingHeight;
var switchDisposer = new CompositeDisposable();
var targetPosition = Vector3.zero;
var xMultiplier = 1f;
var yMultiplier = 1f;
contentSwitchComponent.ScreenSize.DistinctUntilChanged().Subscribe(size =>
{
xMultiplier = width / size.x;
yMultiplier = height / size.y;
targetPosition = new Vector3(contentSwitchComponent.Offset.x * xMultiplier, contentSwitchComponent.Offset.y * yMultiplier, 0);
rectTransform.sizeDelta = new Vector2(contentSwitchComponent.Size.x * xMultiplier, contentSwitchComponent.Size.y * yMultiplier);
rectTransform.position = targetPosition;
}).AddTo(this.Disposer).AddTo(contentSwitchComponent.Disposer);
for (int i = 0; i < viewComponent.Transforms[0].childCount; i++)
{
var go = viewComponent.Transforms[0].GetChild(i).gameObject;
contentSwitchComponent.Contents.Add(go);
go.SetActive(false);
}
EventSystem.Publish(new ContentInitialEvent(contentSwitchComponent, -1, 0));
Observable.EveryUpdate().Where(_ => !contentSwitchComponent.IsPlaying && contentSwitchComponent.Direction != Vector2.zero).Subscribe(__ =>
{
var nextIndex = contentSwitchComponent.Contents[0].activeSelf ? 1 : 0;
var index = nextIndex == 0 ? 1 : 0;
var originPosition = targetPosition - new Vector3(contentSwitchComponent.Direction.x * contentSwitchComponent.Size.x * xMultiplier, contentSwitchComponent.Direction.y * contentSwitchComponent.Size.y * yMultiplier, 0);
var offset = targetPosition - originPosition;
var time = 0f;
contentSwitchComponent.Contents[nextIndex].transform.position = originPosition;
EventSystem.Publish(new ContentSwitchStartEvent(contentSwitchComponent, index, nextIndex));
contentSwitchComponent.Contents[nextIndex].SetActive(true);
Observable.EveryUpdate().SkipWhile(_ => contentSwitchComponents.Entities.Where(e => e.GetComponent <ContentSwitchComponent>().ID == contentSwitchComponent.ID).Any(e => !e.GetComponent <ContentSwitchComponent>().IsReady)).Subscribe(_ =>
{
contentSwitchComponent.Contents[nextIndex].transform.position = Vector3.Lerp(originPosition, targetPosition, contentSwitchComponent.EaseCurve.Evaluate(time));
contentSwitchComponent.Contents[index].transform.position = contentSwitchComponent.Contents[nextIndex].transform.position + offset;
EventSystem.Publish(new ContentSwitchStayEvent(contentSwitchComponent, index, nextIndex));
if (time == 1)
{
EventSystem.Publish(new ContentSwitchCompletedEvent(contentSwitchComponent, index, nextIndex));
contentSwitchComponent.Contents[index].SetActive(false);
contentSwitchComponent.Direction = Vector2.zero;
contentSwitchComponent.IsPlaying = false;
switchDisposer.Clear();
}
time = Mathf.Clamp01(time + contentSwitchComponent.Speed * Time.deltaTime);
}).AddTo(this.Disposer).AddTo(contentSwitchComponent.Disposer).AddTo(switchDisposer);
contentSwitchComponent.IsPlaying = true;
contentSwitchComponent.Direction = Vector2.zero;
}).AddTo(this.Disposer).AddTo(contentSwitchComponent.Disposer);
}).AddTo(this.Disposer);
EventSystem.OnEvent <LidarSwipeEvent>().Subscribe(evt =>
{
var list = contentSwitchComponents.Entities.Select(e => e.GetComponent <ContentSwitchComponent>()).Where(contentSwitchComponent => contentSwitchComponent.ID == evt.ID);
if (list.All(contentSwitchComponent => !contentSwitchComponent.IsPlaying))
{
foreach (var contentSwitchComponent in list)
{
contentSwitchComponent.Direction = evt.Distance;
}
}
}).AddTo(this.Disposer);
}
void OnDestroy()
{
_destroyDispose.Clear();
}
protected override void OnDisappearing()
{
base.OnDisappearing();
EventSubscriptions.Clear();
}
//private void OnDisable()
//{
// _disposables.Dispose();
//}
private void OnDestroy()
{
_isEnable = false;
_disposables.Dispose();
_disposables.Clear();
}
private void OnDestroy()
{
Disposables.Clear();
}
public void LeaveMainGame()
{
mLife.Clear();
}
/// <summary>
/// Cancle all runnining streams, clearing _queHistory
/// </summary>
public void Cancle()
{
_queHistory.Clear();
_tail = null;
}
public void OnDespawned()
{
gameObject.SetActive(false);
_disposables.Clear();
}
public override void ViewWillDisappear(bool animated)
{
base.ViewWillDisappear(animated);
disposeBag.Clear();
}
protected override void OnDisappearing()
{
SubscriptionDisposables.Clear();
base.OnDisappearing();
}
public void Dispose()
{
CompositeDisposable.Clear();
_components.Clear();
}
void RunView(UIViewType viewType, ViewWithData arg = null)
{
if (requestedTarget?.ViewType == viewType || (requestedTarget?.ViewType == UIViewType.None && requestedTarget?.MainFlow == CurrentFlow))
{
arg = requestedTarget;
}
if (arg == null)
{
arg = new ViewWithData {
ActiveFlow = activeFlow, MainFlow = selectedFlow, ViewType = viewType
}
}
;
bool firstTime = CreateViewAndViewModel(viewType, arg);
var view = GetObjectsForFlow(activeFlow)[viewType].View;
transition.OnNext(new LoadData
{
Flow = activeFlow,
View = view,
Data = arg
});
// controller might have been stopped in the OnNext above
if (IsStopped)
{
return;
}
// if it's not the first time we've shown this view, no need
// to set it up
if (!firstTime)
{
return;
}
SetupView(viewType, view.ViewModel);
}
void SetupView(UIViewType viewType, IViewModel viewModel)
{
var list = GetObjectsForFlow(activeFlow);
var pair = list[viewType];
var hasDone = viewModel as IHasDone;
var hasCancel = viewModel as IHasCancel;
// 2FA is set up when login is set up, so nothing to do
if (viewType == UIViewType.TwoFactor)
{
return;
}
// we're setting up the login dialog, we need to setup the 2fa as
// well to continue the flow if it's needed, since the
// authenticationresult callback won't happen until
// everything is done
if (viewType == UIViewType.Login)
{
var pair2fa = list[UIViewType.TwoFactor];
pair2fa.AddHandler(((IDialogViewModel)pair2fa.ViewModel).WhenAny(x => x.IsShowing, x => x.Value)
.Where(x => x)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => Fire(Trigger.Next)));
pair2fa.AddHandler(((IHasCancel)pair2fa.ViewModel).Cancel
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => Fire(uiStateMachine.CanFire(Trigger.Cancel) ? Trigger.Cancel : Trigger.Finish)));
if (hasDone != null)
{
pair.AddHandler(hasDone.Done
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => Fire(Trigger.Finish)));
}
}
else if (hasDone != null)
{
pair.AddHandler(hasDone.Done
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => Fire(uiStateMachine.CanFire(Trigger.Next) ? Trigger.Next : Trigger.Finish)));
}
if (hasCancel != null)
{
pair.AddHandler(hasCancel.Cancel
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => Fire(uiStateMachine.CanFire(Trigger.Cancel) ? Trigger.Cancel : Trigger.Finish)));
}
}
/// <summary>
/// Creates View/ViewModel instances for the specified <paramref name="viewType"/> if they
/// haven't been created yet in the current flow
/// </summary>
/// <param name="viewType"></param>
/// <returns>true if the View/ViewModel didn't exist and had to be created</returns>
bool CreateViewAndViewModel(UIViewType viewType, ViewWithData data = null)
{
var list = GetObjectsForFlow(activeFlow);
if (viewType == UIViewType.Login)
{
if (!list.ContainsKey(viewType))
{
var d = factory.CreateViewAndViewModel(UIViewType.TwoFactor);
list.Add(UIViewType.TwoFactor, d);
}
}
// 2fa view/viewmodel is created when login is created 'cause login needs the 2fa viewmodel
// so the only thing we want to do is connect the viewmodel to the view when it's showing
else if (viewType == UIViewType.TwoFactor)
{
var d = list[viewType];
if (d.View.ViewModel == null)
{
d.ViewModel.Initialize(data);
d.View.DataContext = d.ViewModel;
}
}
IUIPair pair = null;
var firstTime = !list.TryGetValue(viewType, out pair);
if (firstTime)
{
pair = factory.CreateViewAndViewModel(viewType);
}
pair.ViewModel.Initialize(data);
if (firstTime)
{
pair.View.DataContext = pair.ViewModel;
list.Add(viewType, pair);
}
return(firstTime);
}
/// <summary>
/// Returns the view/viewmodel pair for a given flow
/// </summary>
Dictionary <UIViewType, IUIPair> GetObjectsForFlow(UIControllerFlow flow)
{
Dictionary <UIViewType, IUIPair> list;
if (!uiObjects.TryGetValue(flow, out list))
{
list = new Dictionary <UIViewType, IUIPair>();
uiObjects.Add(flow, list);
}
return(list);
}
void Fire(Trigger next, ViewWithData arg = null)
{
Debug.WriteLine("Firing {0} from {1} ({2})", next, uiStateMachine.State, GetHashCode());
if (triggers.ContainsKey(next))
{
uiStateMachine.Fire(triggers[next], arg);
}
else
{
uiStateMachine.Fire(next);
}
}
UIViewType Go(Trigger trigger)
{
return(Go(trigger, activeFlow));
}
UIViewType Go(Trigger trigger, UIControllerFlow flow)
{
var m = machines[flow];
Debug.WriteLine("Firing {0} from {1} for flow {2} ({3})", trigger, m.State, flow, GetHashCode());
m.Fire(trigger);
return(m.State);
}
void Reset()
{
if (connectionAdded != null)
{
connectionManager.Connections.CollectionChanged -= connectionAdded;
}
connectionAdded = null;
var tr = transition;
var cmp = completion;
transition = null;
completion = null;
disposables.Clear();
tr?.Dispose();
cmp?.Dispose();
stopping = false;
connection = null;
}
bool disposed; // To detect redundant calls
public void Dispose()
{
_subscriptions.Dispose();
_subscriptions.Clear();
}
private void OnDisable()
{
_cd.Clear();
_eventIn.Unsubcribe(RaiseEvent);
}
/// <summary>
/// Views the did disappear.
/// </summary>
/// <param name="animated">If set to <c>true</c> animated.</param>
public override void ViewDidDisappear(bool animated)
{
base.ViewDidDisappear(animated);
subscriptionDisposables.Clear();
subscriptionDisposables.Dispose();
}
protected override void OnDisappearing()
{
base.OnDisappearing();
disposable.Clear();
}
private void UnsubscribeFromContext()
{
_contextSubscriptions.Clear();
}
internal void StopObserving()
{
_observingDisposables?.Clear();
}
public virtual void DeInit()
{
_subscriptions.Clear();
}
public void Dispose()
{
_cd?.Clear();
GoToCreateUserCommand?.Dispose();
GoToLoginCommand?.Dispose();
}
void OnDestroy() => disposables.Clear();
private void MainForm_FormClosed(object sender, FormClosedEventArgs e)
{
compositeDisposable.Clear();
viewModel.Unsubscribe();
}
public void Dispose()
{
disposable.Clear();
disposable.Dispose();
}
