internal NavigationService(Frame frame)
{
FrameFacade = new FrameFacade(frame);
FrameFacade.Navigating += async (s, e) =>
{
if (e.Suspending)
return;
// allow the viewmodel to cancel navigation
e.Cancel = !NavigatingFrom(false);
if (!e.Cancel)
{
await NavigateFromAsync(false);
}
};
FrameFacade.Navigated += (s, e) =>
{
NavigateTo(e.NavigationMode, e.Parameter);
};
}
public async Task <bool> NavigateAsync(Type page, object parameter = null, NavigationTransitionInfo infoOverride = null)
{
DebugWrite($"Page: {page}, Parameter: {parameter}, NavigationTransitionInfo: {infoOverride}");
// serialize parameter
var serializedParameter = default(string);
try
{
serializedParameter = SerializationService.Serialize(parameter);
}
catch
{
throw new Exception("Parameter cannot be serialized. See https://github.com/Windows-XAML/Template10/wiki/Page-Parameters");
}
return(await NavigationOrchestratorAsync(page, parameter, NavigationMode.New, () =>
{
return FrameFacade.Navigate(page, serializedParameter, infoOverride);
}));
}
public async Task <bool> LoadAsync()
{
// load navigation state from settings
DebugWrite($"Frame: {FrameFacade.FrameId}");
try
{
var frameState = Suspension.GetFrameState();
if (frameState == null || !frameState.Exists("CurrentPageType"))
{
return(false);
}
CurrentPageType = frameState.Read <Type>("CurrentPageType");
CurrentPageParam = frameState.Read <object>("CurrentPageParam");
FrameFacade.SetNavigationState(frameState.Read <string>("NavigateState"));
while (FrameFacade.Content == null)
{
await Task.Delay(1);
}
var newPage = FrameFacade.Content as Page;
var newViewModel = newPage?.DataContext;
// newTemplate10ViewModel.Properties
if (newViewModel is ITemplate10ViewModel)
{
Navigation.SetupViewModel(this, newViewModel as ITemplate10ViewModel);
}
// newNavigatedAwareAsync.OnNavigatedTo
await Navigation.NavedToAsync(newPage?.DataContext, CurrentPageParam, NavigationMode.Refresh, newPage);
RaiseAfterRestoreSavedNavigation();
return(true);
}
catch { return(false); }
}
protected internal NavigationService(Frame frame)
{
SerializationService = Services.SerializationService.SerializationService.Json;
FrameFacadeInternal = new FrameFacade(this, frame);
FrameFacadeInternal.Navigating += async(s, e) =>
{
if (e.Suspending)
{
return;
}
// allow the viewmodel to cancel navigation
e.Cancel = !(await NavigatingFromAsync(false, e.NavigationMode));
if (!e.Cancel)
{
await NavigateFromAsync(false);
}
};
FrameFacadeInternal.Navigated += async(s, e) =>
{
var parameter = SerializationService.Deserialize(e.Parameter?.ToString());
if (Equals(e.Parameter?.ToString(), SerializationService.Serialize(LastNavigationParameter)))
{
parameter = LastNavigationParameter;
}
await WindowWrapper.Current().Dispatcher.DispatchAsync(async() =>
{
try
{
await NavigateToAsync(e.NavigationMode, parameter, FrameFacadeInternal.Frame.Content);
}
catch (Exception ex)
{
DebugWrite($"DispatchAsync/NavigateToAsync {ex.Message}");
throw;
}
}, 1);
};
}
protected internal NavigationService(Frame frame)
{
FrameFacade = new FrameFacade(frame);
FrameFacade.Navigating += async(s, e) =>
{
if (e.Suspending)
{
return;
}
// allow the viewmodel to cancel navigation
e.Cancel = !NavigatingFrom(false);
if (!e.Cancel)
{
await NavigateFromAsync(false);
}
};
FrameFacade.Navigated += (s, e) =>
{
NavigateTo(e.NavigationMode, ParameterSerializationService.Instance.DeserializeParameter(e.Parameter));
};
}
public NavigationService(Frame frame)
{
_frame = new FrameFacade(frame);
_frame.Navigating += async(s, e) =>
{
if (e.Suspending)
{
return;
}
// allow the viewmodel to cancel navigation
e.Cancel = !NavigatingFrom(false);
if (!e.Cancel)
{
await NavigateFromAsync(false);
}
};
_frame.Navigated += (s, e) =>
{
NavigateTo(e.NavigationMode, e.Parameter);
};
}
public bool Navigate(Type page, object parameter = null, NavigationTransitionInfo infoOverride = null)
{
if (page == null)
{
throw new ArgumentNullException(nameof(page));
}
if (page.FullName.Equals(LastNavigationType))
{
if (parameter == LastNavigationParameter)
{
return(false);
}
if (parameter != null && parameter.Equals(LastNavigationParameter))
{
return(false);
}
}
parameter = ParameterSerializationService.Instance.SerializeParameter(parameter);
return(FrameFacade.Navigate(page, parameter, infoOverride));
}
public void SaveNavigation()
{
if (CurrentPageType == null)
{
return;
}
var state = FrameFacade.PageStateContainer(GetType());
if (state == null)
{
throw new InvalidOperationException("State container is unexpectedly null");
}
state["CurrentPageType"] = CurrentPageType.ToString();
try { state["CurrentPageParam"] = CurrentPageParam; }
catch
{
throw new Exception("Failed to serialize page parameter, override/implement ToString()");
}
state["NavigateState"] = FrameFacade?.GetNavigationState();
}
protected internal NavigationService(Frame frame)
{
FrameFacade = new FrameFacade(frame);
FrameFacade.Navigating += async(s, e) =>
{
if (e.Suspending)
{
return;
}
// allow the viewmodel to cancel navigation
e.Cancel = !NavigatingFrom(false);
if (!e.Cancel)
{
await NavigateFromAsync(false);
}
};
FrameFacade.Navigated += async(s, e) =>
{
var parameter = SerializationService.SerializationService.Deserialize(e.Parameter);
await WindowWrapper.Current().Dispatcher.DispatchAsync(() => { NavigateTo(e.NavigationMode, parameter, Frame.Content); }, 1);
};
}
public bool RestoreSavedNavigation()
{
try
{
var state = FrameFacade.PageStateContainer(GetType());
if (state == null || !state.Any() || !state.ContainsKey("CurrentPageType"))
{
return(false);
}
FrameFacade.CurrentPageType = Type.GetType(state["CurrentPageType"].ToString());
FrameFacade.CurrentPageParam = ParameterSerializationService.Instance.DeserializeParameter(state["CurrentPageParam"]?.ToString());
FrameFacade.SetNavigationState(state["NavigateState"]?.ToString());
NavigateTo(NavigationMode.Refresh, FrameFacade.CurrentPageParam);
while (Frame.Content == null)
{
Task.Yield().GetAwaiter().GetResult();
}
AfterRestoreSavedNavigation?.Invoke(this, FrameFacade.CurrentPageType);
return(true);
}
catch { return(false); }
}
void NavigateTo(NavigationMode mode, object parameter)
{
LastNavigationParameter = parameter;
LastNavigationType = FrameFacade.Content.GetType().FullName;
if (mode == NavigationMode.New)
{
FrameFacade.ClearFrameState();
}
var page = FrameFacade.Content as Page;
if (page != null)
{
if (page.DataContext == null)
{
// to support dependency injection, but keeping it optional.
var viewmodel = BootStrapper.Current.ResolveForPage(page.GetType(), this);
if (viewmodel != null)
{
page.DataContext = viewmodel;
}
}
// call viewmodel
var dataContext = page.DataContext as INavigable;
if (dataContext != null)
{
// prepare for state load
dataContext.NavigationService = this;
dataContext.Dispatcher = Common.WindowWrapper.Current(this)?.Dispatcher;
dataContext.SessionState = BootStrapper.Current.SessionState;
var pageState = FrameFacade.PageStateContainer(page.GetType());
dataContext.OnNavigatedTo(parameter, mode, pageState);
}
}
}
public bool Navigate(Type page, object parameter = null, NavigationTransitionInfo infoOverride = null)
{
DebugWrite($"Page: {page}, Parameter: {parameter}, NavigationTransitionInfo: {infoOverride}");
if (page == null)
{
throw new ArgumentNullException(nameof(page));
}
if (page.FullName.Equals(LastNavigationType))
{
if (parameter == LastNavigationParameter)
{
return(false);
}
if (parameter != null && parameter.Equals(LastNavigationParameter))
{
return(false);
}
}
parameter = SerializationService.SerializationService.Serialize(parameter);
return(FrameFacade.Navigate(page, parameter, infoOverride));
}
public async Task <bool> GoBackAsync(NavigationTransitionInfo infoOverride = null)
{
if (!CanGoBack)
{
return(false);
}
var previous = FrameFacade.BackStack.LastOrDefault();
var parameter = SerializationService.Deserialize(previous.Parameter?.ToString());
return(await NavigationOrchestratorAsync(previous.SourcePageType, parameter, NavigationMode.Back, () =>
{
try
{
FrameFacade.GoBack(infoOverride);
return true;
}
catch (Exception ex)
{
// Catch and ignore exceptions
DebugWrite(ex.Message, Severities.Error);
return false;
}
}));
}
public async Task <bool> GoForwardAsync()
{
if (!FrameFacade.CanGoForward)
{
return(false);
}
var next = FrameFacade.ForwardStack.FirstOrDefault();
var parameter = SerializationService.Deserialize(next.Parameter?.ToString());
return(await NavigationOrchestratorAsync(next.SourcePageType, parameter, NavigationMode.Forward, () =>
{
try
{
FrameFacade.GoForward();
return true;
}
catch (Exception ex)
{
// Catch and ignore exceptions
DebugWrite(ex.Message, Severities.Error);
return false;
}
}));
}
internal NavigationService(Frame frame) : this()
{
FrameFacade = new FrameFacade(frame, this as INavigationService);
_ViewService = new Lazy <IViewService>(() => new ViewService.ViewService());
}
public void GoForward()
{
FrameFacade.GoForward();
}
public void Refresh()
{
FrameFacade.Refresh();
}
public void ClearCache(bool removeCachedPagesInBackStack = false) => FrameFacade.ClearCache(removeCachedPagesInBackStack);
public void RaiseForwardRequested(HandledEventArgs args)
{
ForwardRequested?.Invoke(this, args);
// for backwards compat
FrameFacade.RaiseForwardRequested(args);
}
public void RaiseNavigating(Portable.NavigatingEventArgs e)
{
Navigating?.Invoke(this, e);
// for backwards compat
FrameFacade.RaiseNavigating(e);
}
public SuspensionStateLogic(FrameFacade frame, NavigationService navigationService)
{
this.NavigationService = navigationService;
this.FrameFacade = frame;
}
public void ClearHistory()
{
FrameFacade.SetNavigationState(EmptyNavigation);
}
