public override void OnNavigatedTo(Prism.Navigation.NavigationParameters parameters)
{
base.OnNavigatedTo(parameters);
mText = parameters.GetValue <string>("text");
Debug.WriteLine(mText);
}
public async Task NavedFromAsync(object viewmodel, NavigationMode mode, Page sourcePage, Type sourceType, object sourceParameter, Page targetPage, Type targetType, object targetParameter, bool suspending)
{
Services.NavigationService.NavigationService.DebugWrite();
if (sourcePage == null)
{
return;
}
else if (viewmodel == null)
{
return;
}
else if (viewmodel is Classic.INavigatedAwareAsync)
{
var vm = viewmodel as Classic.INavigatedAwareAsync;
await vm?.OnNavigatedFromAsync(PageState(sourcePage), suspending);
}
else if (viewmodel is Portable.INavigatedAware)
{
var vm = viewmodel as Portable.INavigatedAware;
var parameters = new Portable.NavigationParameters();
vm?.OnNavigatedFrom(parameters);
}
else if (viewmodel is Portable.INavigatedAwareAsync)
{
var vm = viewmodel as Portable.INavigatedAwareAsync;
var parameters = new Portable.NavigationParameters();
await vm?.OnNavigatedFromAsync(parameters);
}
}
public async Task NavedFromAsync(object viewmodel, NavigationMode mode, Page sourcePage, Type sourceType, object sourceParameter, Page targetPage, Type targetType, object targetParameter, bool suspending)
{
Services.NavigationService.NavigationService.DebugWrite();
if (sourcePage == null)
{
return;
}
else if (viewmodel == null)
{
return;
}
else if (viewmodel is Classic.INavigatedAwareAsync)
{
var vm = viewmodel as Classic.INavigatedAwareAsync;
await vm?.OnNavigatedFromAsync(PageState(sourcePage), suspending);
}
else if (viewmodel is Portable.INavigatedAware)
{
var vm = viewmodel as Portable.INavigatedAware;
var parameters = new Portable.NavigationParameters();
vm?.OnNavigatedFrom(parameters);
}
else if (viewmodel is Portable.INavigatedAwareAsync)
{
var vm = viewmodel as Portable.INavigatedAwareAsync;
var parameters = new Portable.NavigationParameters();
await vm?.OnNavigatedFromAsync(parameters);
}
}
public override void OnNavigatingTo(Prism.Navigation.NavigationParameters parameters)
{
_ea.GetEvent <InitializeTabbedChildrenEvent>().Publish(parameters);
/*if (parameters.ContainsKey("parametro"))
* this.Titulo = parameters["parametro"].ToString();*/
}
public override void OnNavigatingTo(Prism.Navigation.NavigationParameters parameters)
{
if (parameters.ContainsKey("Order"))
{
Order = parameters["Order"] as Order;
SetViewFields();
}
}
private async Task infoUserCommand()
{
var navParameters = new Prism.Navigation.NavigationParameters();
navParameters.Add("UserName", UserName);
await _navigationService.NavigateAsync($"/CustomMasterDetailPage/NavigationPage/InfoOfUserMyView", navParameters);
}
void SelectedItem(Item item)
{
var navParameters = new Prism.Navigation.NavigationParameters {
{ "selecttedItem", item }
};
Navigate("DetailItemPage", navParameters);
}
//private void CompletedTaskShow()
//{
// if (ShowCompletedTask)
// {
// //var items = new ObservableCollection<Item>();
// foreach (var item in Items)
// {
// if (item.Completed)
// CompletedItems.Add(item);
// }
// //if(items.Count > 0)
// // CompletedItems = new ObservableCollection<Item>(items);
// }
// else
// {
// CompletedItems.Clear();
// }
// ShowCompletedTask = !ShowCompletedTask;
//}
void EditItem(Item item)
{
var navParameters = new Prism.Navigation.NavigationParameters {
{ "selecttedItem", item }
};
Navigate("AddPage", navParameters);
}
private void MyClickButton()
{
var par = new Prism.Navigation.NavigationParameters();
par.Add("hell", 4);
_navigationService.NavigateAsync("SecondPage", par);
//pageDialogService.DisplayActionSheetAsync("hello", "hi", "ok");
}
public async Task <bool> NavingFromCancelsAsync(object viewmodel, NavigationMode mode, Page sourcePage, Type sourceType, object sourceParameter, Page targetPage, Type targetType, object targetParameter, bool suspending)
{
Services.NavigationService.NavigationService.DebugWrite();
if (sourcePage == null)
{
return(false);
}
else if (viewmodel == null)
{
return(false);
}
else if (viewmodel is Classic.INavigatingAwareAsync)
{
var deferral = new DeferralManager();
var navigatingEventArgs = new Classic.NavigatingEventArgs(deferral)
{
Page = sourcePage,
PageType = sourcePage?.GetType(),
Parameter = sourceParameter,
NavigationMode = mode,
TargetPageType = targetType,
TargetPageParameter = targetParameter,
Suspending = suspending,
};
try
{
var vm = viewmodel as Classic.INavigatingAwareAsync;
await vm?.OnNavigatingFromAsync(navigatingEventArgs);
await deferral.WaitForDeferralsAsync();
}
catch
{
Debugger.Break();
}
return(navigatingEventArgs.Cancel);
}
else if (viewmodel is Portable.IConfirmNavigationAsync)
{
var parameters = new Portable.NavigationParameters();
parameters.Add("NavigationMode", mode.ToPrismNavigationMode());
parameters.Add("SourceType", sourceType);
parameters.Add("SourceParameter", sourceParameter);
parameters.Add("TargetType", targetType);
parameters.Add("TargetParameter", targetParameter);
parameters.Add("Suspending", suspending);
var vm = viewmodel as Portable.IConfirmNavigationAsync;
return(!await vm?.CanNavigateAsync(parameters));
}
else
{
return(true);
}
}
private async Task onlogin()
{
var navParameters = new Prism.Navigation.NavigationParameters();
navParameters.Add("UserName", UserName);
await _navigationService.NavigateAsync(
$"/CustomMasterDetailPage/NavigationPage/MainPageView",
navParameters
);
}
public void OnNavigatedTo_ShouldCallContainsFromShoppingCartService()
{
INavigationParameters navigationParameters = new Prism.Navigation.NavigationParameters();
Dog dog = _dogList[0];
navigationParameters.Add("selectedDogData", dog);
_dogDetailViewModel.OnNavigatedTo(navigationParameters);
_mockShoppingCartService.Verify(x => x.Contains(It.IsAny <int>()), Times.Once());
_mockShoppingCartService.VerifyNoOtherCalls();
}
public void DogAlreadyInTheShoppingCart_OnNavigatedTo_ShouldChangeCanExecuteToFalse()
{
_mockShoppingCartService.Setup(r => r.Contains(It.IsAny <int>())).Returns(true);
_mockAuthenticationService.Setup(r => r.IsUserAuthenticated).Returns(true);
_dogDetailViewModel = new DogDetailViewModel(_mockNavigationService.Object, _mockShoppingCartService.Object, _mockAuthenticationService.Object);
INavigationParameters navigationParameters = new Prism.Navigation.NavigationParameters();
_dogDetailViewModel.SelectedDog = _dogList[0];
_dogDetailViewModel.OnNavigatedTo(navigationParameters);
_dogDetailViewModel.AddSelectedDogToTheShoppingCart.CanExecute(null).Should().BeFalse();
}
private async void Navega()
{
if (Selection != null)
{
// await PageDialogService.DisplayAlertAsync("app", Selection.nome, "Ok");
var navigationParams = new Prism.Navigation.NavigationParameters();
navigationParams.Add("paciente", Selection);
//var mainPage = $"{nameof(NavigationPage)}/{nameof(Exames)}";
await NavigationService.NavigateAsync("Exames", navigationParams);
Selection = null;
}
}
/// <summary>
/// Ons the navigated to.
/// </summary>
/// <param name="parameters">Parameters.</param>
public override void OnNavigatedTo(Prism.Navigation.NavigationParameters parameters)
{
this.Properties = parameters.GetValue <PropertyViewModel>(MagicStrings.Lease);
this.ExecuteAsyncTask(async() =>
{
await Task.WhenAll(new Task[] {
this.LoadAccountStatement(),
this.LoadCurrentBalance(),
});
}).Forget();
base.OnNavigatedTo(parameters);
}
public async Task NavedToAsync(object viewmodel, NavigationMode mode, Page sourcePage, Type sourceType, object sourceParameter, Page targetPage, Type targetType, object targetParameter)
{
Services.NavigationService.NavigationService.DebugWrite();
if (targetPage == null)
{
throw new ArgumentNullException(nameof(targetPage));
}
if (mode == NavigationMode.New)
{
PageState(targetPage).Clear();
}
if (viewmodel == null)
{
return;
}
else if (viewmodel is Classic.INavigatedAwareAsync)
{
var vm = viewmodel as Classic.INavigatedAwareAsync;
await vm?.OnNavigatedToAsync(targetParameter, mode, PageState(targetPage));
}
else if (viewmodel is Portable.INavigatedAware)
{
var parameters = new Portable.NavigationParameters();
parameters.Add("NavigationMode", mode.ToPrismNavigationMode());
parameters.Add("SourceType", sourceType);
parameters.Add("SourceParameter", sourceParameter);
parameters.Add("TargetType", targetType);
parameters.Add("TargetParameter", targetParameter);
var vm = viewmodel as Portable.INavigatedAware;
vm?.OnNavigatedTo(parameters);
}
else if (viewmodel is Portable.INavigatedAwareAsync)
{
var parameters = new Portable.NavigationParameters();
parameters.Add("NavigationMode", mode.ToPrismNavigationMode());
parameters.Add("SourceType", sourceType);
parameters.Add("SourceParameter", sourceParameter);
parameters.Add("TargetType", targetType);
parameters.Add("TargetParameter", targetParameter);
var vm = viewmodel as Portable.INavigatedAwareAsync;
await vm?.OnNavigatedToAsync(parameters);
}
targetPage.InitializeBindings();
targetPage.UpdateBindings();
}
public void OnNavigatedTo_SelectedDogInformations_ShouldBeDisplayed()
{
INavigationParameters navigationParameters = new Prism.Navigation.NavigationParameters();
Dog dog = _dogList[0];
navigationParameters.Add("selectedDogData", dog);
_dogDetailViewModel.OnNavigatedTo(navigationParameters);
_dogDetailViewModel.SelectedDog.Should().BeEquivalentTo(dog);
_dogDetailViewModel.SelectedDog.Description.Should().BeEquivalentTo(dog.Description);
_dogDetailViewModel.SelectedDog.Price.Should().Be(dog.Price);
_dogDetailViewModel.SelectedDog.Race.Should().BeEquivalentTo(dog.Race);
_dogDetailViewModel.SelectedDog.Sex.Should().BeEquivalentTo(dog.Sex);
}
public void UserIsNotAuthenticated_OnNavigatedTo_ShouldChangeAddSelectedDogToTheShoppingCartCanExecuteToFalse()
{
_dogDetailViewModel.SelectedDog = _fixture.CreateFakeDog().Generate();
_dogDetailViewModel.SelectedDog.Id = 1;
_mockShoppingCartService.Setup(r => r.Contains(It.IsAny <int>())).Returns(false);
_mockAuthenticationService.Setup(r => r.IsUserAuthenticated).Returns(false); // <------
var user = _fixture.CreateFakeUser(5).Generate();
_mockAuthenticationService.Setup(r => r.AuthenticatedUser).Returns(user);
INavigationParameters navigationParameters = new Prism.Navigation.NavigationParameters();
_dogDetailViewModel.OnNavigatedTo(navigationParameters);
_dogDetailViewModel.AddSelectedDogToTheShoppingCart.CanExecute(null).Should().BeFalse();
}
public override void OnNavigatedTo(Prism.Navigation.NavigationParameters parameters)
{
todoRepository.GetQueryable()
.SubscribeForNotifications(UpdateTodos);
}
protected virtual async Task ProcessNavigationForMasterDetailPage(MasterDetailPage currentPage, string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated)
{
bool isPresented = GetMasterDetailPageIsPresented(currentPage);
var detail = currentPage.Detail;
if (detail == null)
{
var newDetail = CreatePageFromSegment(nextSegment);
await ProcessNavigation(newDetail, segments, parameters, useModalNavigation, animated);
await DoNavigateAction(null, nextSegment, newDetail, parameters, onNavigationActionCompleted : () =>
{
currentPage.IsPresented = isPresented;
currentPage.Detail = newDetail;
});
return;
}
if (useModalNavigation.HasValue && useModalNavigation.Value)
{
var nextPage = CreatePageFromSegment(nextSegment);
await ProcessNavigation(nextPage, segments, parameters, useModalNavigation, animated);
await DoNavigateAction(currentPage, nextSegment, nextPage, parameters, async() =>
{
currentPage.IsPresented = isPresented;
await DoPush(currentPage, nextPage, true, animated);
});
return;
}
var nextSegmentType = PageNavigationRegistry.GetPageType(UriParsingHelper.GetSegmentName(nextSegment));
if (detail.GetType() == nextSegmentType)
{
await ProcessNavigation(detail, segments, parameters, useModalNavigation, animated);
await DoNavigateAction(null, nextSegment, detail, parameters, onNavigationActionCompleted : () =>
{
currentPage.IsPresented = isPresented;
});
return;
}
else
{
var newDetail = CreatePageFromSegment(nextSegment);
await ProcessNavigation(newDetail, segments, parameters, newDetail is NavigationPage?false : true, animated);
await DoNavigateAction(detail, nextSegment, newDetail, parameters, onNavigationActionCompleted : () =>
{
currentPage.IsPresented = isPresented;
currentPage.Detail = newDetail;
PageUtilities.DestroyPage(detail);
});
return;
}
}
protected virtual async Task ProcessNavigation(Page currentPage, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated)
{
if (segments.Count == 0)
{
return;
}
var nextSegment = segments.Dequeue();
if (nextSegment == RemovePageSegment)
{
await ProcessNavigationForRemovePageSegments(currentPage, nextSegment, segments, parameters, useModalNavigation, animated);
return;
}
if (currentPage == null)
{
await ProcessNavigationForRootPage(nextSegment, segments, parameters, useModalNavigation, animated);
return;
}
if (currentPage is ContentPage)
{
await ProcessNavigationForContentPage(currentPage, nextSegment, segments, parameters, useModalNavigation, animated);
}
else if (currentPage is NavigationPage)
{
await ProcessNavigationForNavigationPage((NavigationPage)currentPage, nextSegment, segments, parameters, useModalNavigation, animated);
}
else if (currentPage is TabbedPage)
{
await ProcessNavigationForTabbedPage((TabbedPage)currentPage, nextSegment, segments, parameters, useModalNavigation, animated);
}
else if (currentPage is CarouselPage)
{
await ProcessNavigationForCarouselPage((CarouselPage)currentPage, nextSegment, segments, parameters, useModalNavigation, animated);
}
else if (currentPage is MasterDetailPage)
{
await ProcessNavigationForMasterDetailPage((MasterDetailPage)currentPage, nextSegment, segments, parameters, useModalNavigation, animated);
}
}
/// <summary>
/// Initiates navigation to the target specified by the <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The type which will be used to identify the name of the navigation target.</typeparam>
/// <param name="parameters">The navigation parameters</param>
/// <param name="useModalNavigation">If <c>true</c> uses PopModalAsync, if <c>false</c> uses PopAsync</param>
/// <param name="animated">If <c>true</c> the transition is animated, if <c>false</c> there is no animation on transition.</param>
public void Navigate <T>(NavigationParameters parameters = null, bool useModalNavigation = true, bool animated = true)
{
Navigate(typeof(T).FullName, parameters, useModalNavigation, animated);
}
protected virtual Task ProcessNavigationForAbsoulteUri(Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated)
{
return(ProcessNavigation(null, segments, parameters, useModalNavigation, animated));
}
protected virtual async Task ProcessNavigationForRemovePageSegments(Page currentPage, string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated)
{
if (!HasNavigationPageParent(currentPage))
{
throw new InvalidOperationException("Removing views using the relative '../' syntax while navigating is only supported within a NavigationPage");
}
List <Page> pagesToRemove = new List <Page>();
pagesToRemove.Add(currentPage);
var currentPageIndex = currentPage.Navigation.NavigationStack.Count;
if (currentPage.Navigation.NavigationStack.Count > 0)
{
currentPageIndex = currentPage.Navigation.NavigationStack.Count - 1;
}
while (segments.Peek() == RemovePageSegment)
{
currentPageIndex -= 1;
pagesToRemove.Add(currentPage.Navigation.NavigationStack[currentPageIndex]);
nextSegment = segments.Dequeue();
}
await ProcessNavigation(currentPage, segments, parameters, useModalNavigation, animated);
var navigationPage = (NavigationPage)currentPage.Parent;
foreach (var page in pagesToRemove)
{
navigationPage.Navigation.RemovePage(page);
PageUtilities.DestroyPage(page);
}
}
protected virtual async Task ProcessNavigationForRootPage(string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated)
{
var nextPage = CreatePageFromSegment(nextSegment);
await ProcessNavigation(nextPage, segments, parameters, useModalNavigation, animated);
var currentPage = _applicationProvider.MainPage;
var modalStack = currentPage?.Navigation.ModalStack.ToList();
await DoNavigateAction(GetCurrentPage(), nextSegment, nextPage, parameters, async() =>
{
await DoPush(null, nextPage, useModalNavigation, animated);
});
if (currentPage != null)
{
PageUtilities.DestroyWithModalStack(currentPage, modalStack);
}
}
public async Task NavedToAsync(object viewmodel, NavigationMode mode, Page sourcePage, Type sourceType, object sourceParameter, Page targetPage, Type targetType, object targetParameter)
{
Services.NavigationService.NavigationService.DebugWrite();
if (targetPage == null)
{
throw new ArgumentNullException(nameof(targetPage));
}
if (mode == NavigationMode.New)
{
PageState(targetPage).Clear();
}
if (viewmodel == null)
{
return;
}
else if (viewmodel is Classic.INavigatedAwareAsync)
{
var vm = viewmodel as Classic.INavigatedAwareAsync;
await vm?.OnNavigatedToAsync(targetParameter, mode, PageState(targetPage));
}
else if (viewmodel is Portable.INavigatedAware)
{
var parameters = new Portable.NavigationParameters();
parameters.Add("NavigationMode", mode.ToPrismNavigationMode());
parameters.Add("SourceType", sourceType);
parameters.Add("SourceParameter", sourceParameter);
parameters.Add("TargetType", targetType);
parameters.Add("TargetParameter", targetParameter);
var vm = viewmodel as Portable.INavigatedAware;
vm?.OnNavigatedTo(parameters);
}
else if (viewmodel is Portable.INavigatedAwareAsync)
{
var parameters = new Portable.NavigationParameters();
parameters.Add("NavigationMode", mode.ToPrismNavigationMode());
parameters.Add("SourceType", sourceType);
parameters.Add("SourceParameter", sourceParameter);
parameters.Add("TargetType", targetType);
parameters.Add("TargetParameter", targetParameter);
var vm = viewmodel as Portable.INavigatedAwareAsync;
await vm?.OnNavigatedToAsync(parameters);
}
targetPage.InitializeBindings();
targetPage.UpdateBindings();
}
protected virtual async Task ProcessNavigationForContentPage(Page currentPage, string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated)
{
var nextPageType = PageNavigationRegistry.GetPageType(UriParsingHelper.GetSegmentName(nextSegment));
bool useReverse = UseReverseNavigation(currentPage, nextPageType);
if (!useReverse)
{
var nextPage = CreatePageFromSegment(nextSegment);
await ProcessNavigation(nextPage, segments, parameters, useModalNavigation, animated);
await DoNavigateAction(currentPage, nextSegment, nextPage, parameters, async() =>
{
await DoPush(currentPage, nextPage, useModalNavigation, animated);
});
}
else
{
await UseReverseNavigation(currentPage, nextSegment, segments, parameters, useModalNavigation, animated);
}
}
public async Task<bool> NavingFromCancelsAsync(object viewmodel, NavigationMode mode, Page sourcePage, Type sourceType, object sourceParameter, Page targetPage, Type targetType, object targetParameter, bool suspending)
{
Services.NavigationService.NavigationService.DebugWrite();
if (sourcePage == null)
{
return false;
}
else if (viewmodel == null)
{
return false;
}
else if (viewmodel is Classic.INavigatingAwareAsync)
{
var deferral = new DeferralManager();
var navigatingEventArgs = new Classic.NavigatingEventArgs(deferral)
{
Page = sourcePage,
PageType = sourcePage?.GetType(),
Parameter = sourceParameter,
NavigationMode = mode,
TargetPageType = targetType,
TargetPageParameter = targetParameter,
Suspending = suspending,
};
try
{
var vm = viewmodel as Classic.INavigatingAwareAsync;
await vm?.OnNavigatingFromAsync(navigatingEventArgs);
await deferral.WaitForDeferralsAsync();
}
catch
{
Debugger.Break();
}
return navigatingEventArgs.Cancel;
}
else if (viewmodel is Portable.IConfirmNavigationAsync)
{
var parameters = new Portable.NavigationParameters();
parameters.Add("NavigationMode", mode.ToPrismNavigationMode());
parameters.Add("SourceType", sourceType);
parameters.Add("SourceParameter", sourceParameter);
parameters.Add("TargetType", targetType);
parameters.Add("TargetParameter", targetParameter);
parameters.Add("Suspending", suspending);
var vm = viewmodel as Portable.IConfirmNavigationAsync;
return !await vm?.CanNavigateAsync(parameters);
}
else
{
return true;
}
}
public override void OnNavigatingTo(Prism.Navigation.NavigationParameters parameters)
{
System.Diagnostics.Debug.WriteLine($"{Title} OnNavigatingTo");
_ea.GetEvent <InitializeTabbedChildrenEvent>().Publish(parameters);
}
protected virtual async Task ProcessNavigationForNavigationPage(NavigationPage currentPage, string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated)
{
if (currentPage.Navigation.NavigationStack.Count == 0)
{
await UseReverseNavigation(currentPage, nextSegment, segments, parameters, false, animated);
return;
}
var clearNavigationStack = GetClearNavigationPageNavigationStack(currentPage);
var isEmptyOfNavigationStack = currentPage.Navigation.NavigationStack.Count == 0;
List <Page> destroyPages;
if (clearNavigationStack && !isEmptyOfNavigationStack)
{
destroyPages = currentPage.Navigation.NavigationStack.ToList();
destroyPages.Reverse();
await currentPage.Navigation.PopToRootAsync(false);
}
else
{
destroyPages = new List <Page>();
}
var topPage = currentPage.Navigation.NavigationStack.LastOrDefault();
var nextPageType = PageNavigationRegistry.GetPageType(UriParsingHelper.GetSegmentName(nextSegment));
if (topPage?.GetType() == nextPageType)
{
if (clearNavigationStack)
{
destroyPages.Remove(destroyPages.Last());
}
if (segments.Count > 0)
{
await UseReverseNavigation(topPage, segments.Dequeue(), segments, parameters, false, animated);
}
await DoNavigateAction(topPage, nextSegment, topPage, parameters);
}
else
{
await UseReverseNavigation(currentPage, nextSegment, segments, parameters, false, animated);
if (clearNavigationStack && !isEmptyOfNavigationStack)
{
currentPage.Navigation.RemovePage(topPage);
}
}
foreach (var destroyPage in destroyPages)
{
PageUtilities.DestroyPage(destroyPage);
}
}
protected virtual async Task ProcessNavigationForCarouselPage(CarouselPage currentPage, string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated)
{
var nextPage = CreatePageFromSegment(nextSegment);
await ProcessNavigation(nextPage, segments, parameters, useModalNavigation, animated);
await DoNavigateAction(currentPage, nextSegment, nextPage, parameters, async() =>
{
await DoPush(currentPage, nextPage, useModalNavigation, animated);
});
}
protected static async Task DoNavigateAction(Page fromPage, string toSegment, Page toPage, NavigationParameters parameters, Func <Task> navigationAction = null, Action onNavigationActionCompleted = null)
{
var segmentParameters = UriParsingHelper.GetSegmentParameters(toSegment, parameters);
segmentParameters.Add(KnownNavigationParameters.NavigationMode, NavigationMode.New);
var canNavigate = await PageUtilities.CanNavigateAsync(fromPage, segmentParameters);
if (!canNavigate)
{
return;
}
OnNavigatingTo(toPage, segmentParameters);
if (navigationAction != null)
{
await navigationAction();
}
OnNavigatedFrom(fromPage, segmentParameters);
onNavigationActionCompleted?.Invoke();
OnNavigatedTo(toPage, segmentParameters);
}
protected virtual async Task UseReverseNavigation(Page currentPage, string nextSegment, Queue <string> segments, NavigationParameters parameters, bool?useModalNavigation, bool animated)
{
var navigationStack = new Stack <string>();
if (!String.IsNullOrWhiteSpace(nextSegment))
{
navigationStack.Push(nextSegment);
}
var illegalSegments = new Queue <string>();
bool illegalPageFound = false;
foreach (var item in segments)
{
//if we run itno an illegal page, we need to create new navigation segments to properly handle the deep link
if (illegalPageFound)
{
illegalSegments.Enqueue(item);
continue;
}
var pageType = PageNavigationRegistry.GetPageType(UriParsingHelper.GetSegmentName(item));
if (IsSameOrSubclassOf <MasterDetailPage>(pageType))
{
illegalSegments.Enqueue(item);
illegalPageFound = true;
}
else
{
navigationStack.Push(item);
}
}
var pageOffset = currentPage.Navigation.NavigationStack.Count;
if (currentPage.Navigation.NavigationStack.Count > 2)
{
pageOffset = currentPage.Navigation.NavigationStack.Count - 1;
}
bool insertBefore = false;
while (navigationStack.Count > 0)
{
var segment = navigationStack.Pop();
var nextPage = CreatePageFromSegment(segment);
await DoNavigateAction(currentPage, segment, nextPage, parameters, async() =>
{
await DoPush(currentPage, nextPage, useModalNavigation, animated, insertBefore, pageOffset);
});
insertBefore = true;
}
//if an illegal page is found, we force a Modal navigation
if (illegalSegments.Count > 0)
{
await ProcessNavigation(currentPage.Navigation.NavigationStack.Last(), illegalSegments, parameters, true, animated);
}
}
