public Task OnNavigatingFromAsync(NavigatingEventArgs args)
 {
     if (galleryMetaInfo == null)
         BootStrapper.Current.SessionState["GalleryInfo"] = new GalleryMetaInfo { Gallery = Images, SelectedIndex = FlipViewIndex };
     else
         galleryMetaInfo.SelectedIndex = FlipViewIndex;
     return Task.CompletedTask;
 }

 public override void OnNavigatingFrom(NavigatingEventArgs args)
 {
     try
     {
         ApplicationView view = ApplicationView.GetForCurrentView();
         view.ExitFullScreenMode();
     }
     catch (Exception)
     {
     }
 }

 // before navigate (cancellable)
 bool NavigatingFrom(bool suspending)
 {
     var page = FrameFacade.Content as Page;
     if (page != null)
     {
         var dataContext = page.DataContext as INavigable;
         if (dataContext != null)
         {
             var args = new NavigatingEventArgs
             {
                 PageType = FrameFacade.CurrentPageType,
                 Parameter = FrameFacade.CurrentPageParam,
                 Suspending = suspending,
             };
             dataContext.OnNavigatingFrom(args);
             return !args.Cancel;
         }
     }
     return true;
 }

        private void FacadeNavigatingCancelEventHandler(object sender, NavigatingCancelEventArgs e)
        {
            DebugWrite();

            object parameter = null;
            try
            {
                parameter = SerializationService.Deserialize(e.Parameter?.ToString());
            }
            catch (Exception ex)
            {
                throw new Exception("Your parameter must be serializable. If it isn't, then use SessionState.", ex);
            }
            var args = new NavigatingEventArgs(e, Content as Page, parameter);
            if (NavigationModeHint != NavigationMode.New)
                args.NavigationMode = NavigationModeHint;
            NavigationModeHint = NavigationMode.New;
            foreach (var handler in _navigatingEventHandlers)
            {
                handler(this, args);
            }
            e.Cancel = args.Cancel;
        }

        private void FacadeNavigatingCancelEventHandler(object sender, NavigatingCancelEventArgs e)
        {
            DebugWrite();

            var parameter = SerializationService.Deserialize(e.Parameter?.ToString());
            var args = new NavigatingEventArgs(e, Content as Page, parameter);
            if (NavigationModeHint != NavigationMode.New)
                args.NavigationMode = NavigationModeHint;
            NavigationModeHint = NavigationMode.New;
            foreach (var handler in _navigatingEventHandlers)
            {
                handler(this, args);
            }
            e.Cancel = args.Cancel;
        }

        public override async Task OnNavigatingFromAsync(NavigatingEventArgs args)
        {
          

            await base.OnNavigatingFromAsync(args);
        }

 public override void OnNavigatingFrom(NavigatingEventArgs args)
 {
     args.Cancel = false;
 }

 public override Task OnNavigatingFromAsync(NavigatingEventArgs args)
 {
     args.Cancel = false;
     return Task.CompletedTask;
 }

 public override async Task OnNavigatingFromAsync(NavigatingEventArgs args)
 {
     args.Cancel = false;
     await Task.CompletedTask;
 }

 public override Task OnNavigatingFromAsync(NavigatingEventArgs args)
 {
     return base.OnNavigatingFromAsync(args);
 }

 private void FacadeNavigatingCancelEventHandler(object sender, NavigatingCancelEventArgs e)
 {
     var args = new NavigatingEventArgs(e, Content as Page);
     if (NavigationModeHint != NavigationMode.New)
         args.NavigationMode = NavigationModeHint;
     NavigationModeHint = NavigationMode.New;
     foreach (var handler in _navigatingEventHandlers)
     {
         handler(this, args);
     }
     e.Cancel = args.Cancel;
 }

 public override async void OnNavigatingFrom(NavigatingEventArgs args)
 {
     await ExecuteSaveCommand();
 }

 public override Task OnNavigatingFromAsync(NavigatingEventArgs args)
 {
     _dispatcherTimer.Stop();
     return Task.CompletedTask;
 }

        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 Task OnNavigatingFromAsync(NavigatingEventArgs args)
 {
     _beaconManagementService.StopAdvertising();
     return base.OnNavigatingFromAsync(args);
 }

 public override async Task OnNavigatingFromAsync(NavigatingEventArgs args)
 {
     //args.Parameter = Recipe;
     //args.Cancel = false;
     SessionState.Add("UpdatedRecipe", Recipe);
     await Task.CompletedTask;
 }

 public virtual void OnNavigatingFrom(NavigatingEventArgs args) { /* nothing by default */ }

        public override void OnNavigatingFrom(NavigatingEventArgs args)        {

            mediaElement.Source = null;
            base.OnNavigatingFrom(args);
        }

 private void FacadeNavigatingCancelEventHandler(object sender, NavigatingCancelEventArgs e)
 {
     var args = new NavigatingEventArgs(e);
     foreach (var handler in _navigatingEventHandlers)
     {
         handler(this, args);
     }
     e.Cancel = args.Cancel;
 }

 public override async Task OnNavigatingFromAsync(NavigatingEventArgs args)
 {
     args.Cancel = false;
     // Stops map timer
     GameClient.ToggleUpdateTimer(false);
     GameClient.MapPokemonUpdated -= GameClientOnMapPokemonUpdated;
     await Task.CompletedTask;
 }