Intercept Back Button Call in UINavigationController?

[Ben-G]

Problem: When using ReSwiftRouter we want every view controller change to be reflected by a route update. This means we need to be notified when UIKit's container view controllers trigger VCs to be presented or hidden.

For UITabBarController we can implement delegate methods to intercept view controller changes and allow the router to change view controllers instead of the controller handling the changes directly.

For the back button of UINavigationController there's no comparable solution. Right now I'm using a workaround that I'm not very happy with: https://github.com/ReSwift/GitHubBrowserExample/blob/master/SwiftFlowGitHubBrowser/ViewControllers/RepositoryDetailViewController.swift#L37-L41

When a VC disappears, I check if the current route is still the one of the current VC. If that's the case, we know that the VC was dismissed without the route being updated; in response I update the route manually.

Any suggestions on how to intercept back button taps more directly are welcome. Ideally this would not involve replacing bar button items, or any other larger modifications of the UINavigationController.

[jschmid]

There is also didMoveToParentViewController:, but this also means that every view controller must implement this method :/

[yammada]

I've encountered this exact same issue in my own small scale experiments with unidirectional data flow architecture. I realized that the problem is not only intercepting taps from the back button, but also the standard edge swipe gestures, so any sort of button trickery doesn't seem to work.

One possibility that's similar to your solution, but at least doesn't require participation from every child VC, is using - navigationController:didShowViewController:animated:. It would still involve a manual update to the route by filtering, since it doesn't actually between a pop or a push, but it works.

Another downside with taking over the delegate though is that it's also responsible for custom transitions, so splitting that out becomes another potential headache if you want maintain standard UINC behavior.

[ivanmisuno]

I ran into the same problem, and also trying to use UINavigationControllerDelegate.
For every view controller I push into navigation stack, I set associated route:

    // In Root Routable:
    // MARK: - Routable
    func pushRouteSegment(routeElementIdentifier: RouteElementIdentifier,
        animated: Bool,
        completionHandler: RoutingCompletionHandler) -> Routable
    {
        // ...
        let viewController = self.viewControllerForPushingWithSegment(segment)
        self.navigationController.pushViewController_(viewController, animated: animated, completion: completionHandler)
    }

    func viewControllerForPushingWithSegment(segment: RoutableSegment) -> ViewControllerPresentationInterop
    {
        let viewController = self.viewControllerFactory.viewControllerForRouteSegment(segment)
        self.setViewControllerCurrentNavigationState(viewController)
        return viewController
    }
    func setViewControllerCurrentNavigationState(viewController: ViewControllerPresentationInterop)
    {
        if let navigationController = viewController as? NavigationControllerPresentationInterop {
            if let topViewController = navigationController.topViewController_ {
                self.setViewControllerCurrentNavigationState(topViewController)
            }
        }
        if var viewControllerWithRoute = viewController as? HasNavigationRoute {
            // set associated route
            viewControllerWithRoute.navigationRoute = self.navigationState.route
        }
    }
    // ...
    // Root Routable has to subscribe to NavigationState updates
    func newState(state: NavigationState) {
        self.navigationState_ = state
    }

Then, in the root NavigationController's delegate I check that the route stored in a view controller being presented matches the expected route and correct the latter if necessary:

    // UINavigationControllerDelegate
    func navigationController(navigationController: UINavigationController, didShowViewController viewController: UIViewController, animated: Bool) {
        // ...
        self.verifyRouteIsSynced(nc: navigationController, c: viewController, animated: animated)
    }
    // ...
    func verifyRouteIsSynced(nc nc: NavigationControllerPresentationInterop, c: ViewControllerPresentationInterop, animated: Bool)
    {
        if let viewControllerWithRoute = c as? HasNavigationRoute {
            if let viewControllerRoute = viewControllerWithRoute.navigationRoute {
                if self.navigationState.route != viewControllerRoute {
                    debugPrint("correcting route for \(c) from (\(self.navigationState.route)) to (\(viewControllerRoute))")
                    let store = self.getStoreBlock()
                    store.dispatch(SetRouteAction(viewControllerRoute, animated: false))
                }
            }
        }
    }

This is somewhat dirty:

• UIViewController has to be extended to support storing associated route;
• Root routable has to subscribe to state updates to track current (expected) NavigationState, and needs to dispatch actions to the store, which somewhat breaks initial concept.

The real problem, however, is that SetRouteAction() dispatched in verifyRouteIsSynced tries to initiate changes in the UI (via Routable callbacks), that have already been made by user pushing "Back" button. For this I need only to update store's NavigationState and Routable structure, while skipping actual changes to UI.

[Ben-G]

Stumbled across isMovingFromParentViewController method on UIViewController today; based on the documentation it might be another viable candidate.

[Ben-G]

Another relevant read that covers the same issue using the coordinator pattern: http://irace.me/navigation-coordinators

[Ben-G]

Another potential approach: implementing the UINavigationBarDelegate which has a method that can prevent popping view controllers. Details here: http://stackoverflow.com/a/21462109/1046430

[dodikk]

So what is the client code workaround or approach for dealing with UINavigationController ?
How about adding some hints to the README.md file?

I've faced the issue when the NavigationState.route does not get updated when the user taps back button of UINavigationController. So my navigation actions end up dispatching to a wrong Routable sub-class.

$ cat Cartfile.resolved 
github "ReSwift/ReSwift" "3.0.0"
github "ReSwift/ReSwiftRouter" "0.5.1"

Here is some supplementary code

    // Root

class RootRoutable : Routable
{
    fileprivate func routableToLoginWizardVC() -> Routable
    {
        // instantiate VC from storyboard
        let nextVC = PKStoryboardFactory.loadLoginWizardVC()

        // add navigation and present explicitly
        let navigation = UINavigationController(rootViewController: nextVC)
        self.window.rootViewController = navigation
        
        return LoginWizardRoutable(withActiveVC: nextVC)
    }

...
}

    @IBAction func onLoginEmailButtonTapped(_ sender: UIButton?)
    {
        let currentRoute = store.state.navigationState.route

        // when back button is tapped the last element of currentRoute is still there
        // seems like I have to hard code the routes
        let nextRoute = currentRoute + [loginRoute]
        
        let routeToNextScreenAction = ReSwiftRouter.SetRouteAction(nextRoute)
        store.dispatch(routeToNextScreenAction)
    }

po routeToNextScreenAction
▿ SetRouteAction
  ▿ route : 3 elements
    - 0 : "login_or_register_selector"
    - 1 : "login"
    - 2 : "login"
  - animated : true

[dodikk]

Sorry for spamming. I've found the "invoke route manually in viewWillDisappear" workaround in a github client example.

Still, isn't this approach worth mentioning in a readme?
At least until a better solution is implemented.

[rpassis]

@Ben-G thanks for the reference article on #17 (comment)

I've been able to implemented something similar and it seems to be working well.

For anyone trying to find a more elegant solution to this, here's a quick overview of what I've done. Feel free to ping me if you need any other details.

1. Create a new protocol RoutableIdentifiable that inherits from Routable. Change your routables to adopt and conform to this protocol.

protocol RoutableIdentifiable: Routable {
    var routeIdentifier: RouteElementIdentifier { get set }
}

2. Create a NavigationController proxy class that bridges to your UINavigationController

class NavigationController: UIViewController, UINavigationControllerDelegate {

    let rootViewController: UIViewController
    private let childNavigationController: UINavigationController

    required init(rootViewController: UIViewController) {
        self.rootViewController = rootViewController
        self.childNavigationController =
            UINavigationController(rootViewController: rootViewController)
        super.init(nibName: nil, bundle: nil)
        self.childNavigationController.delegate = self
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        configureChildViewController()
    }

    private func configureChildViewController() {
        addChildViewController(childNavigationController)
        view.addSubview(childNavigationController.view)
        childNavigationController.didMove(toParentViewController: self)
        // Setup your constraints here if required
    }

    // Expose any UINavigationController methods as required (i.e. push, pop, etc)
    ...

    // MARK: NavController delegate
    // We use the navigationController delegate method for animation controllers
    // as it gives us a reference to the source and destination view controllers. 
    // This method is called after the navigation controller state has been updated
    // so the viewControllers array will reflect what the navigation stack is 
    // supposed to be. From here, we can simply check if the viewControllers array contains 
    // the source view controller and then ensure that our navigation state is correct

    func navigationController(_ navigationController: UINavigationController, animationControllerFor
        operation: UINavigationControllerOperation, from fromVC: UIViewController, to toVC:
        UIViewController) -> UIViewControllerAnimatedTransitioning? {
        if navigationController.viewControllers.contains(fromVC) == false {
            // The source view controller was popped, let's check if the state needs updating
            guard let vc = fromVC as? RoutableIdentifiable else { return nil }
            var newRoute = mainStore.state.navigationState.route
            let lastRouteElementIdentifier = newRoute.last
            if vc.routeIdentifier.rawValue == lastRouteElementIdentifier {
                _ = newRoute.popLast()
                mainStore.dispatch(ReSwiftRouter.SetRouteAction(newRoute))
            }
            return nil
        }
        return nil
    }

[Ben-G]

@rpassis Sorry for the super late response on this. I've been on a long vacation and pretty swamped ever since I'm back. But your solution is actually really good compared to everything we have so far (actually we've implemented something similar for the router we're using at PlanGrid).

Once I've freed up a little bit of time it would nice to document this solution or maybe even incorporate it into the library somehow.

[dagio]

@rpassis can you conform that with your solution, if you do not dispatch SetRouteAction the view controller will be poped anyway ? I mean in that case it seems the state is lagging behind the UI.

[rpassis]

@dagio the view controller will be popped irrespective of setting the route. The idea is that we are ensuring the route state is in sync with the UI when triggering actions that are hard to capture (ie. back button press or swipe right).

[dagio]

@rpassis did you manage to keep the native swipe gesture of the navigation view controller in order to pop the current view controller ?
When implementing func navigationController(_ navigationController: UINavigationController, animationControllerFor operation: UINavigationControllerOperation, from fromVC: UIViewController, to toVC: UIViewController) -> UIViewControllerAnimatedTransitioning? in our delegate, then the gesture is not available anymore

At the moment we are using func navigationController(_ navigationController: UINavigationController, didShow viewController: UIViewController, animated: Bool). It does the job. The native swipe gesture work. The back button too. The NavigationState get updated.

import UIKit
import ReSwift
import ReSwiftRouter

/**
 This delegate disable the back button in UIKit and dispatch a routing action instead
 */

public class RoutingNavigationControllerDelegate<S: StateType>: NSObject, UINavigationControllerDelegate {

    private let store: Store<S>
    private let navigationStateSelector: (S) -> NavigationState
    private var currentViewController: UIViewController?

    public init(store: Store<S>, navigationStateSelector: @escaping (S) -> NavigationState) {
        self.store = store
        self.navigationStateSelector = navigationStateSelector
    }

    public func navigationController(_ navigationController: UINavigationController, didShow viewController: UIViewController, animated: Bool) {

        guard let fromVC = currentViewController else {
            self.currentViewController = viewController

            return
        }

        if navigationController.viewControllers.contains(fromVC) == false {
            // The source view controller was popped, let's check if the state needs updating

            // If the source view controller does not conform to RoutableIdentifiable
            // then do nothing
            guard let sourceVC = fromVC as? RoutableIdentifiable else {
                NSLog("The source view controller does not conform to RoutableIdentifiable. Did you forget to conform your view controller to the protocol ?")

                return
            }

            // Here we mean by current route the one that is in the navigation state.
            // At this moment the user has taped on the back button, however the navigation
            // state has not changed. Therefore the current route should still be the same
            let currentRoute = navigationStateSelector(store.state).route
            let currentRouteElementIdentifier = currentRoute.last

            // If the source view controller is the one of the current route
            if sourceVC.routeIdentifier == currentRouteElementIdentifier {
                // Create destinationRoute as copy of currentRoute so we can make some change on it
                var destinationRoute = currentRoute
                _ = destinationRoute.popLast()
                store.dispatch(ReSwiftRouter.SetRouteAction(destinationRoute))

                store.dispatch(DeleteRouteSpecificData(route: currentRoute))
            }
        }

        self.currentViewController = viewController
    }
}