public async Task Conductor_ConductWithTests() { var root = new Conductor <StateScreen> .Collection.AllActive(); var child1 = new StateScreen { DisplayName = "screen1" }; var child2 = new StateScreen(TimeSpan.FromSeconds(3)) { DisplayName = "screen2" }; var child3 = new StateScreen() { DisplayName = "screen3" }; root.Items.Add(child1); root.Items.Add(child2); root.Items.Add(child3); await ScreenExtensions.TryActivateAsync(root).ConfigureAwait(false); await ScreenExtensions.TryDeactivateAsync(root, true).ConfigureAwait(false); Assert.True(child1.IsClosed, "child 1 should be closed"); Assert.True(child2.IsClosed, "child 2 should be closed"); Assert.True(child3.IsClosed, "child 3 should be closed"); }
public async Task Screen_ConductWithTests() { var root = new Screen(); var child1 = new StateScreen { DisplayName = "screen1" }; // simulate a long deactivation process var child2 = new StateScreen(TimeSpan.FromSeconds(3)) { DisplayName = "screen2" }; var child3 = new StateScreen() { DisplayName = "screen3" }; child1.ConductWith(root); child2.ConductWith(root); child3.ConductWith(root); await ScreenExtensions.TryActivateAsync(root).ConfigureAwait(false); await ScreenExtensions.TryDeactivateAsync(root, true).ConfigureAwait(false); Assert.True(child1.IsClosed, "child 1 should be closed"); Assert.True(child2.IsClosed, "child 2 should be closed"); Assert.True(child3.IsClosed, "child 3 should be closed"); }
/// <summary> /// Activates the specified item. /// </summary> /// <param name="item">The item to activate.</param> /// <param name="cancellationToken">The cancellation token to cancel operation.</param> /// <returns>A task that represents the asynchronous operation.</returns> public override async Task ActivateItemAsync(T item, CancellationToken cancellationToken = default) { if (item == null) { return; } item = this.EnsureItem(item); if (this.IsActive) { await ScreenExtensions.TryActivateAsync(item, cancellationToken); } this.OnActivationProcessed(item, true); }
/// <summary> /// Activates the specified item. /// </summary> /// <param name="item">The item to activate.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param> /// <returns>A task that represents the asynchronous operation.</returns> public override async Task ActivateItemAsync(T item, CancellationToken cancellationToken = default) { if (item != null && item.Equals(this.ActiveItem)) { if (this.IsActive) { await ScreenExtensions.TryActivateAsync(item, cancellationToken); this.OnActivationProcessed(item, true); } return; } await this.ChangeActiveItemAsync(item, false, cancellationToken); }
private async Task AddDialogAsync(IDialog dialog, CancellationToken cancellationToken) { await semaphore.WaitAsync(); try { if (dialog is IActivate activatable && !activatable.IsActive) { await ScreenExtensions.TryActivateAsync(dialog, cancellationToken); } if (Items.Contains(dialog)) { if (!instanceCounter.ContainsKey(dialog)) { instanceCounter.Add(dialog, 0); } instanceCounter[dialog]++; return; } var topMostDialog = OpenDialogs.LastOrDefault(); if (topMostDialog != null) { topMostDialog.IsDialogEnabled = false; } dialog.IsDialogEnabled = true; Items.Add(dialog); DialogOpened?.Invoke(this, dialog); } finally { semaphore.Release(); } }
/// <inheritdoc /> public override async Task ActivateItemAsync(T item, CancellationToken cancellationToken = default) { if (item != null && item.Equals(this.ActiveItem)) { if (this.IsActive) { await ScreenExtensions.TryActivateAsync(item, cancellationToken); this.OnActivationProcessed(item, true); } return; } var closeResult = await this.CloseStrategy.ExecuteAsync(new[] { this.ActiveItem }, cancellationToken); if (closeResult.CloseCanOccur) { await this.ChangeActiveItemAsync(item, true, cancellationToken); } else { this.OnActivationProcessed(item, false); } }
/// <inheritdoc /> public override async Task ActivateItemAsync(T item, CancellationToken cancellationToken) { if (item != null && item.Equals(ActiveItem)) { if (IsActive) { await ScreenExtensions.TryActivateAsync(item, cancellationToken); OnActivationProcessed(item, true); } return; } ICloseResult <T> closeResult = await CloseStrategy.ExecuteAsync(new[] { ActiveItem }, cancellationToken); if (closeResult.CloseCanOccur) { await ChangeActiveItemAsync(item, true, cancellationToken); } else { OnActivationProcessed(item, false); } }
public override async void ViewDidLoad() { base.ViewDidLoad(); await ScreenExtensions.TryActivateAsync(viewModel); }
public async Task ActivateAsync(object activationArgs) { if (IsInteractive(activationArgs)) { // Initialize services that you need before app activation // take into account that the splash screen is shown while this code runs. await InitializeAsync(); // Do not repeat app initialization when the Window already has content, // just ensure that the window is active if (Window.Current.Content == null) { // Create a Shell or Frame to act as the navigation context if (_shell?.Value == null) { var frame = new Frame(); NavigationService = _container.RegisterNavigationService(frame); Window.Current.Content = frame; } else { var viewModel = ViewModelLocator.LocateForView(_shell.Value); ViewModelBinder.Bind(viewModel, _shell.Value, null); await ScreenExtensions.TryActivateAsync(viewModel); NavigationService = _container.GetInstance <INavigationService>(); Window.Current.Content = _shell?.Value; } } } var activationHandler = GetActivationHandlers() .FirstOrDefault(h => h.CanHandle(activationArgs)); if (activationHandler != null) { await activationHandler.HandleAsync(activationArgs); } if (IsInteractive(activationArgs)) { var activation = activationArgs as IActivatedEventArgs; if (activation.PreviousExecutionState == ApplicationExecutionState.Terminated) { await Singleton <SuspendAndResumeService> .Instance.RestoreSuspendAndResumeData(); } var defaultHandler = new DefaultActivationHandler(_defaultNavItem, NavigationService); if (defaultHandler.CanHandle(activationArgs)) { await defaultHandler.HandleAsync(activationArgs); } // Ensure the current window is active Window.Current.Activate(); // Tasks after activation await StartupAsync(); } }
/// <summary> /// Called when activating. /// </summary> /// <param name="cancellationToken">The cancellation token to cancel operation.</param> /// <returns>A task that represents the asynchronous operation.</returns> protected override Task OnActivateAsync(CancellationToken cancellationToken) { return(ScreenExtensions.TryActivateAsync(this.ActiveItem, cancellationToken)); }
protected override async void OnResume() { base.OnResume(); await ScreenExtensions.TryActivateAsync(viewModel); }