Ejemplo n.º 1
0
        public virtual void RequestNavigation(NavigationRequest e)
        {
            if (_navGraph == null)
            {
                var navGraphNavigator =
                    (NavGraphNavigator)NavHost
                    .NavController
                    .NavigatorProvider
                    .GetNavigator(Java.Lang.Class.FromType(typeof(NavGraphNavigator)));

                _navGraph = new NavGraph(navGraphNavigator);


                var callbacks = new Callbacks(this);
                NavHost.NavController.AddOnDestinationChangedListener(callbacks);
                NavHost.ChildFragmentManager.RegisterFragmentLifecycleCallbacks(callbacks, false);
            }

            ApplyNavigationRequest(e);
        }
Ejemplo n.º 2
0
        /*
         * The important thing to know going into reading this method is that it's not possible to
         * modify the backstack. You can only push and pop to and from the top of the stack.
         * So if a user uses an API like `RemovePage` or `InsertPage` we will typically ignore processing those natively
         * unless it requires changes to the NavBar (i.e removing the first page with only 2 pages on the stack).
         * Once the user performs an operation that changes the currently visible page then we process any stack changes
         * that have occurred.
         * Let's say the user has pages A,B,C,D on the stack
         * If they remove Page B and Page C then we don't do anything. Then if the user pushes E onto the stack
         * we just transform A,B,C,D into A,D,E.
         * Natively that's a "pop" but we use the correct animation for a "push" so visually it looks like a push.
         * This is also the reason why we aren't using the custom animation features on the navigation component itself.
         * Because we might be natively popping but visually pushing.
         *
         * The Fragments that are on the stack also do not have a hard connection to the page they originally rendereded.
         * Whenever a fragment is the "visible" fragment it just figures out what the current page is and displays that.
         * Fragments are recreated everytime they are pushed on the stack but the handler renderer is not.
         * It's just attached to a new fragment
         * */
        void ApplyNavigationRequest(NavigationRequest args)
        {
            if (IsNavigating)
            {
                // This should really never fire for the developer. Our xplat code should be handling waiting for navigation to
                // complete before requesting another navigation from Core
                // Maybe some day we'll put a navigation queue into Core? For now we won't
                throw new InvalidOperationException("Previous Navigation Request is still Processing");
            }

            if (args.NavigationStack.Count == 0)
            {
                throw new InvalidOperationException("NavigationStack cannot be empty");
            }

            ActiveRequestedArgs = args;
            IReadOnlyList <IView> newPageStack = args.NavigationStack;
            bool animated                     = args.Animated;
            var  navController                = NavHost.NavController;
            var  previousNavigationStack      = NavigationStack;
            var  previousNavigationStackCount = previousNavigationStack.Count;
            bool initialNavigation            = NavigationStack.Count == 0;

            // This updates the graphs public navigation stack property so it's outwardly correct
            // But we've saved off the previous stack so we can correctly interpret navigation
            UpdateNavigationStack(newPageStack);

            // This indicates that this is the first navigation request so we need to initialize the graph
            if (initialNavigation)
            {
                IsInitialNavigation = true;
                Initialize(args.NavigationStack);
                return;
            }

            // If the new stack isn't changing the visible page or the app bar then we just ignore
            // the changes because there's no point to applying these to the native back stack
            // We only apply changes when the currently visible page changes and/or the appbar
            // will change (gain a back button)
            if (newPageStack[newPageStack.Count - 1] == previousNavigationStack[previousNavigationStackCount - 1] &&
                newPageStack.Count > 1 &&
                previousNavigationStackCount > 1)
            {
                NavigationFinished(NavigationView);
                return;
            }

            // The incoming fragment uses these variables to pick the correct animation for the current
            // incoming navigation request
            if (newPageStack[newPageStack.Count - 1] == previousNavigationStack[previousNavigationStackCount - 1])
            {
                IsPopping = null;
            }
            else
            {
                IsPopping = newPageStack.Count < previousNavigationStackCount;
            }

            IsAnimated = animated;

            var iterator = NavHost.NavController.BackStack.Iterator();
            var fragmentNavDestinations = new List <FragmentNavigator.Destination>();

            while (iterator.HasNext)
            {
                if (iterator.Next() is NavBackStackEntry nbse &&
                    nbse.Destination is FragmentNavigator.Destination nvd)
                {
                    fragmentNavDestinations.Add(nvd);
                }
            }

            // Current BackStack has less entries then incoming new page stack
            // This will add Back Stack Entries until the back stack and the new stack
            // match up
            if (fragmentNavDestinations.Count < newPageStack.Count)
            {
                for (int i = fragmentNavDestinations.Count; i < newPageStack.Count; i++)
                {
                    var dest = AddFragmentDestination();
                    navController.Navigate(dest.Id);
                }
            }
            // User just wants to replace the currently visible page but the number
            // of items in the stack are still the same.
            // In theory we could just prompt the currently active fragment to swap out the new PageView
            // But this way we get an animation
            else if (newPageStack.Count == fragmentNavDestinations.Count)
            {
                int lastFragId = fragmentNavDestinations[newPageStack.Count - 1].Id;
                navController.PopBackStack();
                navController.Navigate(lastFragId);
            }
            // Our back stack has more entries on it then
            else
            {
                int popToId = fragmentNavDestinations[newPageStack.Count - 1].Id;
                navController.PopBackStack(popToId, false);
            }

            // We only keep destinations around that are on the backstack
            // This iterates over the new backstack and removes any destinations
            // that are no longer apart of the back stack
            var iterateNewStack = NavHost.NavController.BackStack.Iterator();
            int startId         = -1;

            while (iterateNewStack.HasNext)
            {
                if (iterateNewStack.Next() is NavBackStackEntry nbse &&
                    nbse.Destination is FragmentNavigator.Destination nvd)
                {
                    fragmentNavDestinations.Remove(nvd);

                    if (startId == -1)
                    {
                        startId = nvd.Id;
                    }
                }
            }

            foreach (var activeDestinations in fragmentNavDestinations)
            {
                NavGraph.Remove(activeDestinations);
            }

            // If we end up removing the destination that was initially the StartDestination
            // The Navigation Graph can get really confused
            if (NavGraph.StartDestination != startId)
            {
                NavGraph.StartDestination = startId;
            }
        }