public void Clear()
{
s_DefaultParams.Clear();
// Destroy all screens on navigation stack.
while (m_NavigationStack.Count > 0)
{
var screen = m_NavigationStack.Pop();
screen.OnScreenDestroyed(s_DefaultParams);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
screen.UpdateDisplayAsync(NavigationMode.Removed, false);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
}
m_NavigationStack.Clear();
// Destroy current screen.
if (m_Current != null)
{
m_Current.OnScreenDestroyed(s_DefaultParams);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
m_Current.UpdateDisplayAsync(NavigationMode.Removed, false);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
m_Current = null;
}
}
private void OnScreenDestroyed(IScreenController screen)
{
if (registeredScreens.ContainsKey(screen.GetType()))
{
UnregisterScreen((T)screen);
}
}
public PrepareLevelHandler(
[NotNull] IScreenController screenController,
[NotNull] IRoundController roundController)
{
_screenController = screenController ?? throw new ArgumentNullException(nameof(screenController));
_roundController = roundController ?? throw new ArgumentNullException(nameof(roundController));
}
/// <inheritdoc />
public Task PushWithNewStackAsync(string screen, INavigationParameters parameters, AnimationOptions animationOptions)
{
if (m_IsBusy)
{
return(Task.CompletedTask);
}
if (string.IsNullOrWhiteSpace(screen))
{
throw new ArgumentNullException(nameof(screen));
}
if (m_Current != null && !m_Current.CanNavigate(parameters))
{
return(Task.CompletedTask);
}
if (m_NavigationStack.Count != 0)
{
s_DefaultParams.Clear();
// Destroy all screens in between
while (m_NavigationStack.Count > 0)
{
IScreenController oldScreen = m_NavigationStack.Pop();
oldScreen.OnScreenDestroyed(s_DefaultParams);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
oldScreen.UpdateDisplayAsync(NavigationMode.Removed, false);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
}
}
return(PushAsync(screen, parameters, animationOptions, false));
}
public StartupManager(
IFileManager fileManager,
IObjectFactory objectFactory,
IScreenController screenController)
{
FileManager = fileManager;
ObjectFactory = objectFactory;
ScreenController = screenController;
}
/// <inheritdoc />
public bool TryGetScreen(string screenId, out IScreenController screen)
{
if (string.IsNullOrEmpty(screenId))
{
throw new ArgumentNullException(nameof(screenId));
}
return(m_Screens.TryGetValue(screenId, out screen));
}
public StartupManager(
IFileManager fileManager,
IObjectFactory objectFactory,
IScreenController screenController)
{
FileManager = fileManager;
ObjectFactory = objectFactory;
ScreenController = screenController;
}
private void RemoveTransition(IScreenController screen)
{
screensTransitioning.Remove(screen);
if (IsScreenTransitionInProgress == false)
{
RequestScreenUnblock?.Invoke();
}
}
private void OnOutAnimationFinished(IScreenController controller)
{
RemoveTransition(controller);
IWindowController window = controller as IWindowController;
if (window.IsPopup)
{
priorityParaLayer.RefreshDarken();
}
}
public void CloseScreen(IScreenController screen)
{
if (screen != CurrentScreens.Last())
{
throw new ArgumentException("Only the top screen can be closed.");
}
screen.DestroyResources();
CurrentScreens.Remove(screen);
_reverseScreens = CurrentScreens.ReverseIterator().ToArray();
}
public object CreateScreen(string screenName, IValueStack stack, IScreenController controller, object styleCache)
{
controller.SetCurrentScreenController();
string tsName = "CreateScreen: " + screenName;
TimeStamp.Start(tsName);
var screenStream = ApplicationContext.Current.Dal.GetScreenByName(screenName);
if (screenStream == null)
{
throw new Exception(String.Format("Can't load screen {0}", screenName));
}
TimeStamp.Log(tsName, "Prepare");
TimeStamp.Start(tsName);
controller.OnLoading(screenName);
TimeStamp.Log(tsName, "OnLoading invoke");
TimeStamp.Start(tsName);
var scr = (IControl <object>)ObjectFactory.CreateObject(stack, screenStream);
TimeStamp.Log(tsName, "Parse screen");
TimeStamp.Start(tsName);
// GC.Collect();
// TimeStamp.Log(tsName, "GC collect");
// TimeStamp.Start(tsName);
scr.CreateView(); // TODO: Replace to platform controllers
TimeStamp.Log(tsName, "Create views");
ApplyStyles(screenName, scr, styleCache);
TimeStamp.Start(tsName);
controller.OnLoad(screenName);
TimeStamp.Log(tsName, "OnLoad invoke");
ApplicationContext.Current.Dal.ClearStringCache();
TimeStamp.WriteAll();
TimeCollector.WriteAll();
return(scr);
}
/// <inheritdoc />
public void Unregister(IScreenController screen)
{
if (screen == null)
{
throw new ArgumentNullException(nameof(screen));
}
if (string.IsNullOrEmpty(screen.id))
{
throw new ArgumentNullException(nameof(screen.id), "Screen ID cannot be null or empty!");
}
m_Screens.Remove(screen.id);
}
public MapConfigurationViewController(
IGeofenceService geofenceService,
ISessionContext sessionContext,
IScreenController screenController)
{
this.GeofenceService = geofenceService;
this.SessionContext = sessionContext;
this.ScreenController = screenController;
this.GeofenceMapDelegate = new GeofenceMapDelegate();
if (!this.GeofenceService.IsInitialized)
{
this.GeofenceService.Initialize();
}
}
public NavigationService(
ILogger logger,
IScreenController router,
IScopeManager scopeManager,
IScreenToViewModelMapper mapper,
IEntryScreenNameProvider entryScreenNameProvider
)
{
_entryScreenNameProvider = entryScreenNameProvider;
_mapper = mapper;
_scopeManager = scopeManager;
_router = router;
_logger = logger;
}
public MapConfigurationViewController(
IGeofenceService geofenceService,
ISessionContext sessionContext,
IScreenController screenController)
{
this.GeofenceService = geofenceService;
this.SessionContext = sessionContext;
this.ScreenController = screenController;
this.GeofenceMapDelegate = new GeofenceMapDelegate();
if (!this.GeofenceService.IsInitialized)
{
this.GeofenceService.Initialize();
}
}
public object CreateScreen(string screenName, IValueStack stack, IScreenController controller, object styleCache)
{
controller.SetCurrentScreenController();
string tsName = "CreateScreen: " + screenName;
TimeStamp.Start(tsName);
var screenStream = ApplicationContext.Current.Dal.GetScreenByName(screenName);
if (screenStream == null)
throw new Exception(String.Format("Can't load screen {0}", screenName));
TimeStamp.Log(tsName, "Prepare");
TimeStamp.Start(tsName);
controller.OnLoading(screenName);
TimeStamp.Log(tsName, "OnLoading invoke");
TimeStamp.Start(tsName);
var scr = (IControl<object>)ObjectFactory.CreateObject(stack, screenStream);
TimeStamp.Log(tsName, "Parse screen");
TimeStamp.Start(tsName);
// GC.Collect();
// TimeStamp.Log(tsName, "GC collect");
// TimeStamp.Start(tsName);
scr.CreateView(); // TODO: Replace to platform controllers
TimeStamp.Log(tsName, "Create views");
ApplyStyles(screenName, scr, styleCache);
TimeStamp.Start(tsName);
controller.OnLoad(screenName);
TimeStamp.Log(tsName, "OnLoad invoke");
ApplicationContext.Current.Dal.ClearStringCache();
TimeStamp.WriteAll();
TimeCollector.WriteAll();
return scr;
}
private void ProcessScreenRegister <T>(T screenPrefab, BaseLayer <T> layer) where T : IScreenController
{
Type screenType = screenPrefab.GetType();
ScreenEntry screenEntry;
if (registeredScreens.TryGetValue(screenType, out screenEntry) == false)
{
Component prefabAsComponent = screenPrefab as Component;
Component screenInstance = Instantiate(prefabAsComponent, mainCanvas.transform);
screenInstance.gameObject.SetActive(false);
IScreenController screenController = (IScreenController)screenInstance;
screenEntry = new ScreenEntry(screenPrefab, screenController);
layer.RegisterScreen((T)screenEntry.ScreenInstance);
layer.ReparentScreen(screenController, screenInstance.transform);
registeredScreens.Add(screenType, screenEntry);
}
screenEntry.ReferenceCount++;
}
public PuppetMaster(IScreenController screenController, ISearchObject searchObject, ILogger logger, bool autoRecover = false)
{
ScreenController = screenController;
MouseController = new MouseController(searchObject.Mode);
KeyboardController = new KeyboardController();
Logger = logger;
SearchObject = searchObject;
SearchLoadingTimer = new Timer();
SearchLoadingTimer.Elapsed += SearchTimerOnElapsed;
SearchLoadingTimer.Interval = Convert.ToInt32(ConfigurationManager.AppSettings["SearchingMarketWaitTime"]);
CaptchaMonitorTimer = new Timer();
CaptchaMonitorTimer.Elapsed += CaptchaMonitorTimerOnElapsed;
CaptchaMonitorTimer.Interval = Convert.ToInt32(ConfigurationManager.AppSettings["CaptchaMonitorWaitTime"]);
ProcessingInterrupted = false;
CurrentInterrupt = InterruptScreen.None;
PurchaseLoopIterations = Convert.ToInt32(ConfigurationManager.AppSettings["purchaseLoopIterations"]);
MsBetweenPurchaseClicks = Convert.ToInt32(ConfigurationManager.AppSettings["purchaseLoopMsBetweenClicks"]);
AutoRecover = autoRecover;
API = new ApiProvider();
}
public override void ReparentScreen(IScreenController controller, Transform screenTransform)
{
IWindowController window = controller as IWindowController;
bool doBaseReparent = true;
if (window == null)
{
Debug.LogError($"Screen {screenTransform.name} is not a Window!");
}
else
{
if (window.IsPopup)
{
priorityParaLayer.AddScreen(screenTransform);
doBaseReparent = false;
}
}
if (doBaseReparent)
{
base.ReparentScreen(controller, screenTransform);
}
}
private bool IsPrefabValid(IScreenController screen)
{
Component screenAsComponent = screen as Component;
if (screenAsComponent == null)
{
Debug.LogError($"The Screen to register must derive from {typeof(Component).Name}");
return(false);
}
if (IsPrefab(screenAsComponent.gameObject) == false)
{
Debug.LogError($"{screenAsComponent.gameObject.name} must be a Prefab.");
return(false);
}
if (registeredScreens.TryGetValue(screen.GetType(), out ScreenEntry entry) && entry.ScreenPrefab != screen)
{
Debug.LogError($"{screen.GetType().Name} already registered with a different Prefab.");
return(false);
}
return(true);
}
public void SetCurrentController(IScreenController controller)
{
_evaluator.SetController(controller);
}
public Pager(IScreenController screenController, IInputController inputController, IFileReader fileReader)
{
_screenController = screenController;
_inputController = inputController;
_fileReader = fileReader;
}
public void SetCurrentController(IScreenController controller)
{
throw new NotImplementedException();
}
public virtual void Init(IScreenController controller)
{
_controller = controller;
}
public void SetCurrentController(IScreenController controller)
{
_evaluator.SetController(controller);
}
public bool Equals(IScreenController other)
{
return(other.id == id);
}
public virtual void ReparentScreen(IScreenController controller, Transform screenTransform)
{
screenTransform.SetParent(transform, false);
}
public ExitMenuHandler([NotNull] IScreenController screenController)
{
_screenController = screenController ?? throw new ArgumentNullException(nameof(screenController));
}
private async Task PushInternalAsync(string screen, INavigationParameters parameters, AnimationOptions animationOptions, bool addToHistory = true)
{
if (m_IsBusy)
{
return;
}
if (string.IsNullOrEmpty(screen))
{
throw new ArgumentNullException(nameof(screen));
}
IScreenController nextScreen = null;
if (!m_ScreenRegistry.TryGetScreen(screen, out nextScreen))
{
throw new ArgumentNullException(nameof(screen), $"Screen with id {screen} does not exist!");
}
if (m_Current != null && !m_Current.CanNavigate(parameters))
{
return;
}
if (m_Current != null && addToHistory)
{
m_NavigationStack.Push(m_Current);
}
try
{
m_IsBusy = true;
if (!animationOptions.enabled)
{
if (m_Current != null)
{
m_Current.OnNavigatingAway(parameters);
await m_Current.UpdateDisplayAsync(NavigationMode.Leaving, false);
if (!addToHistory)
{
m_Current.OnScreenDestroyed(s_DefaultParams);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
m_Current.UpdateDisplayAsync(NavigationMode.Removed, false);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
}
}
m_Current = nextScreen;
m_Current.Prepare();
m_Current.OnNavigatingTo(parameters);
await m_Current.UpdateDisplayAsync(NavigationMode.Entering, false);
m_Current.OnNavigatedTo(parameters);
}
else
{
if (animationOptions.playSynchronously)
{
m_ParallelTasks.Clear();
if (m_Current != null)
{
m_Current.OnNavigatingAway(parameters);
m_ParallelTasks.Add(m_Current.UpdateDisplayAsync(NavigationMode.Leaving));
}
nextScreen.Prepare();
nextScreen.OnNavigatingTo(parameters);
m_ParallelTasks.Add(nextScreen.UpdateDisplayAsync(NavigationMode.Entering));
await Task.WhenAll(m_ParallelTasks);
if (m_Current != null && !addToHistory)
{
m_Current.OnScreenDestroyed(s_DefaultParams);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
m_Current.UpdateDisplayAsync(NavigationMode.Removed, false);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
}
m_Current = nextScreen;
m_Current.OnNavigatedTo(parameters);
}
else
{
if (m_Current != null)
{
m_Current.OnNavigatingAway(parameters);
await m_Current.UpdateDisplayAsync(NavigationMode.Leaving);
if (!addToHistory)
{
m_Current.OnScreenDestroyed(s_DefaultParams);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
m_Current.UpdateDisplayAsync(NavigationMode.Removed, false);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
}
}
m_Current = nextScreen;
m_Current.Prepare();
m_Current.OnNavigatingTo(parameters);
await m_Current.UpdateDisplayAsync(NavigationMode.Entering);
m_Current.OnNavigatedTo(parameters);
}
}
m_EventManager.Invoke(new NavigationCompletedEvent(m_Current.id, m_NavigationStack));
}
catch (Exception e)
{
Debug.LogException(e);
}
finally
{
m_IsBusy = false;
}
}
private void OnCloseRequestedByWindow(IScreenController controller)
{
HideScreen(controller as IWindowController);
}
protected void InitializeMVC(TScreenView view, TScreenModel model, TScreenController controller)
{
this.View = view;
this.Model = model;
this.Controller = controller;
}
/// <inheritdoc />
public async Task PopAsync(INavigationParameters parameters, AnimationOptions animationOptions)
{
if (m_IsBusy)
{
return;
}
if (m_Current == null)
{
throw new InvalidOperationException("Cannot pop if there is no screen current being displayed!");
}
if (!m_Current.CanNavigate(parameters))
{
return;
}
IScreenController previousScreen = null;
if (m_NavigationStack.Count != 0)
{
previousScreen = m_NavigationStack.Pop();
}
try
{
m_IsBusy = true;
if (!animationOptions.enabled)
{
m_Current.OnScreenDestroyed(parameters);
await m_Current.UpdateDisplayAsync(NavigationMode.Removed, false);
if (previousScreen != null)
{
m_Current = previousScreen;
m_Current.OnNavigatingBack(parameters);
await m_Current.UpdateDisplayAsync(NavigationMode.Returning, false);
m_Current.OnNavigatedBack(parameters);
}
else
{
m_Current = null;
}
}
else
{
if (animationOptions.playSynchronously)
{
m_Current.OnScreenDestroyed(parameters);
m_ParallelTasks.Clear();
m_ParallelTasks.Add(m_Current.UpdateDisplayAsync(NavigationMode.Removed));
if (previousScreen != null)
{
previousScreen.OnNavigatingBack(parameters);
m_ParallelTasks.Add(previousScreen.UpdateDisplayAsync(NavigationMode.Returning));
}
await Task.WhenAll(m_ParallelTasks);
if (previousScreen != null)
{
m_Current = previousScreen;
m_Current.OnNavigatedBack(parameters);
}
else
{
m_Current = null;
}
}
else
{
m_Current.OnScreenDestroyed(parameters);
await m_Current.UpdateDisplayAsync(NavigationMode.Removed);
m_Current = previousScreen;
m_Current.OnNavigatingBack(parameters);
await m_Current.UpdateDisplayAsync(NavigationMode.Returning);
m_Current.OnNavigatedBack(parameters);
}
m_EventManager.Invoke(new NavigationCompletedEvent(m_Current.id, m_NavigationStack));
}
}
catch (Exception e)
{
Debug.LogException(e);
}
finally
{
m_IsBusy = false;
}
}
public PincodeSetPasswordDelegate(IScreenController screenController)
{
this.screenController = screenController;
}
public PincodeSetPasswordDelegate(IScreenController screenController)
{
this.screenController = screenController;
}
private void AddTransition(IScreenController screen)
{
screensTransitioning.Add(screen);
RequestScreenBlock?.Invoke();
}
