Detecting Modal Presentation vs Navigation Stack Push in iOS View Controllers

Problem Background and Challenges

In iOS application development, view controllers (UIViewController) are primarily presented in two ways: modally presented or pushed onto a navigation stack. Accurately distinguishing between these presentation methods is crucial for properly handling view controller lifecycles, interaction logic, and interface layout. However, in practice, this problem is often more complex than it initially appears.

Developers might first attempt to use the presentingViewController and isMovingToParentViewController properties for detection, but quickly discover that both properties can return YES in either presentation scenario, providing no reliable distinction. The complexity arises because sometimes a parent view controller is itself presented modally, while the view controller being examined is pushed onto this modal controller's navigation stack.

A typical complex scenario occurs when developers embed a custom HtmlViewController within a UINavigationController, then present this navigation controller modally. In such cases, simple detection methods fail because the view controller exists both within a navigation stack and is presented modally.

HtmlViewController* termsViewController = [[HtmlViewController alloc] initWithDictionary:dictionary];
UINavigationController* modalViewController;

modalViewController = [[UINavigationController alloc] initWithRootViewController:termsViewController];
modalViewController.modalTransitionStyle = UIModalTransitionStyleCoverVertical;
[self presentViewController:modalViewController
                   animated:YES
                 completion:nil];

Core Detection Logic Analysis

To accurately determine whether a view controller is presented modally, multiple factors must be considered. The most reliable detection method is based on a logical combination of three conditions:

1. Check if the current view controller's presentingViewController property is not nil
2. Check if the current view controller's navigation controller is presented modally
3. Check if the current view controller's tab bar controller is presented modally

In Objective-C, this detection logic can be implemented as follows:

- (BOOL)isModal {
    if([self presentingViewController])
        return YES;
    if([[[self navigationController] presentingViewController] presentedViewController] == [self navigationController])
        return YES;
    if([[[self tabBarController] presentingViewController] isKindOfClass:[UITabBarController class]])
        return YES;
    
    return NO;
}

The logic of this method is: first check if the current controller has a direct presenting view controller; if not, check if the current controller's navigation controller is presented modally; if still not, check if the current controller's tab bar controller is presented modally. Only when all conditions are unsatisfied does it return NO.

Swift Implementation

In Swift, we can provide the same functionality by extending UIViewController. Here's an implementation based on Swift 5:

extension UIViewController {
    var isModal: Bool {
        let presentingIsModal = presentingViewController != nil
        let presentingIsNavigation = navigationController?.presentingViewController?.presentedViewController == navigationController
        let presentingIsTabBar = tabBarController?.presentingViewController is UITabBarController
        
        return presentingIsModal || presentingIsNavigation || presentingIsTabBar
    }
}

This implementation uses Swift's optional chaining feature, making the code more concise and safe. Note that special handling is required when view controllers are embedded in navigation controllers and presented modally. Here's a more comprehensive solution:

extension UIViewController {
    var isModal: Bool {
        if let index = navigationController?.viewControllers.firstIndex(of: self), index > 0 {
            return false
        } else if presentingViewController != nil {
            return true
        } else if navigationController?.presentingViewController?.presentedViewController == navigationController {
            return true
        } else if tabBarController?.presentingViewController is UITabBarController {
            return true
        } else {
            return false
        }
    }
}

This improved version first checks the current view controller's position in the navigation stack. If it's not the first controller in the stack (i.e., not the root controller), then it must have been pushed, returning false immediately. This check addresses the scenario where view controllers are pushed within modally presented navigation stacks.

Alternative Detection Methods

Besides the comprehensive detection method above, iOS provides the isBeingPresented method, which can be useful in specific scenarios. This method is particularly valuable in view controller lifecycle methods:

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];

    if ([self isBeingPresented]) {
        // Being presented modally
    } else if ([self isMovingToParentViewController]) {
        // Being pushed onto navigation stack
    } else {
        // Simply reappearing because another VC was dismissed
    }
}

The isBeingPresented method returns YES when the view controller is being presented modally and NO when being pushed onto a navigation stack. This method is suitable for scenarios requiring immediate presentation detection when the view controller appears.

Practical Applications and Considerations

In actual development, the choice of detection method depends on specific application scenarios. The comprehensive detection method (isModal) is suitable for determining presentation state at any time, while the isBeingPresented method is better suited for use within lifecycle methods.

It's important to note that when a view controller is embedded in a UINavigationController and presented modally, simple presentingViewController checks fail because the current view controller's presentingViewController is nil, while the navigation controller's presentingViewController is the actual presenting controller. This is why the detection logic must include checks for navigation controllers.

Another consideration involves tab bar controllers. When view controllers are embedded in tab bar controllers that are presented modally, special handling is required. The third condition in the detection logic addresses this scenario.

Performance Optimization and Best Practices

While the detection methods described generally work correctly, in performance-sensitive scenarios, consider these optimizations:

1. Cache detection results: If the presentation method doesn't change during the lifecycle, cache results after first detection
2. Avoid frequent calls: Reduce unnecessary calls in scenarios not requiring real-time detection
3. Use appropriate timing: Perform one-time detection in viewDidLoad or viewWillAppear

The best practice is to determine the presentation method during view controller initialization or early lifecycle methods, storing this information for subsequent use. This avoids complex property checks each time the information is needed.

Conclusion

Accurately determining iOS view controller presentation methods is a deceptively complex problem. By comprehensively combining checks of presentingViewController, navigationController, and tabBarController properties, reliable detection of modal presentation can be achieved. In Swift, extending UIViewController with computed properties makes this functionality more usable and safe.

For specific lifecycle detection needs, the isBeingPresented method provides a lightweight alternative. Regardless of the chosen method, understanding the complexity of iOS view controller hierarchy is key to correctly implementing these detection logics.