¿Cómo verificar si un controlador de vista se presenta modalmente o se presiona en una pila de navegación?

¿Cómo puedo, en mi código de controlador de vista, diferenciar entre:

• presentado modalmente
• empujado en la pila de navegación

Ambos presentingViewControllery isMovingToParentViewControllerson YESen ambos casos, por lo que no son de mucha ayuda.

Lo que complica las cosas es que mi controlador de vista principal es a veces modal, en el que se empuja el controlador de vista que se va a verificar.

Resulta que mi problema es que inserto mi HtmlViewControlleren uno UINavigationControllerque luego se presenta. Es por eso que mis propios intentos y las buenas respuestas a continuación no estaban funcionando.

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

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

Supongo que será mejor que le diga a mi controlador de vista cuando sea modal, en lugar de tratar de determinarlo.

Tomar con un grano de sal, no probado.

- (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;
 }

En Swift :

Agregue una bandera para probar si es modal por tipo de clase:

// MARK: - UIViewController implementation

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
    }
}

Usted pasa por alto un método: isBeingPresented.

isBeingPresented es verdadero cuando se presenta el controlador de vista y falso cuando se lo empuja.

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

    if ([self isBeingPresented]) {
        // being presented
    } else if ([self isMovingToParentViewController]) {
        // being pushed
    } else {
        // simply showing again because another VC was dismissed
    }
}

Swift 5
Aquí hay una solución que aborda el problema mencionado con las respuestas anteriores, cuando se isModal()devuelve truesi se presiona UIViewControllerestá en una UINavigationControllerpila presentada .

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
        }
    }
}

Funciona para mí hasta ahora. Si hay algunas optimizaciones, por favor comparta.

self.navigationController! = nil significaría que está en una pila de navegación.

Para manejar el caso de que el controlador de vista actual se presiona mientras el controlador de navegación se presenta modalmente, he agregado algunas líneas de código para verificar si el controlador de vista actual es el controlador raíz en la pila de navegación.

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 let navigationController = navigationController, navigationController.presentingViewController?.presentedViewController == navigationController {
            return true
        } else if let tabBarController = tabBarController, tabBarController.presentingViewController is UITabBarController {
            return true
        } else {
            return false
        }
    }
}

Swift 4

var isModal: Bool {
    return presentingViewController != nil ||
           navigationController?.presentingViewController?.presentedViewController === navigationController ||
           tabBarController?.presentingViewController is UITabBarController
}

Swift 5. Limpio y simple.

if navigationController.presentingViewController != nil {
    // Navigation controller is being presented modally
}

Como muchas personas aquí sugieren, que los métodos de "verificación" no funcionan bien en todos los casos, en mi proyecto se me ocurrió una solución para administrarlo manualmente. El punto es que, por lo general, gestionamos la presentación por nuestra cuenta; esto no es lo que sucede detrás de escena y debemos introspectarlo.

DEViewController.h expediente:

#import <UIKit/UIKit.h>

// it is a base class for all view controllers within a project
@interface DEViewController : UIViewController 

// specify a way viewcontroller, is presented  by another viewcontroller
// the presented view controller should manually assign the value to it
typedef NS_ENUM(NSUInteger, SSViewControllerPresentationMethod) {
    SSViewControllerPresentationMethodUnspecified = 0,
    SSViewControllerPresentationMethodPush,
    SSViewControllerPresentationMethodModal,
};
@property (nonatomic) SSViewControllerPresentationMethod viewControllerPresentationMethod;

// other properties/methods...
@end

Las presentaciones ahora se podrían gestionar de esta manera:

empujado en la pila de navegación:

// DETestViewController inherits from DEViewController
DETestViewController *vc = [DETestViewController new];
vc.viewControllerPresentationMethod = SSViewControllerPresentationMethodPush;
[self.navigationController pushViewController:vc animated:YES];

presentado modalmente con navegación:

DETestViewController *vc = [DETestViewController new];
vc.viewControllerPresentationMethod = SSViewControllerPresentationMethodModal;
UINavigationController *nav = [[UINavigationController alloc]
                               initWithRootViewController:vc];
[self presentViewController:nav animated:YES completion:nil];

presentado modalmente:

DETestViewController *vc = [DETestViewController new];
vc.viewControllerPresentationMethod = SSViewControllerPresentationMethodModal;
[self presentViewController:vc animated:YES completion:nil];

Además, en DEViewControllerpodríamos agregar una alternativa a la "verificación" si la propiedad mencionada es igual a SSViewControllerPresentationMethodUnspecified:

- (BOOL)isViewControllerPushed
{
    if (self.viewControllerPresentationMethod != SSViewControllerPresentationMethodUnspecified) {
        return (BOOL)(self.viewControllerPresentationMethod == SSViewControllerPresentationMethodPush);
    }

    else {
        // fallback to default determination method
        return (BOOL)self.navigationController.viewControllers.count > 1;
    }
}

Suponiendo que todos los viewControllers que presentas modalmente están envueltos dentro de un nuevo navigationController (que siempre debes hacer de todos modos), puedes agregar esta propiedad a tu VC.

private var wasPushed: Bool {
    guard let vc = navigationController?.viewControllers.first where vc == self else {
        return true
    }

    return false
}

Para detectar que su controlador es presionado o no, simplemente use el siguiente código en el lugar que desee:

if ([[[self.parentViewController childViewControllers] firstObject] isKindOfClass:[self class]]) {

    // Not pushed
}
else {

    // Pushed
}

Espero que este código pueda ayudar a cualquiera ...

self.navigationController != nil significaría que está en una pila de navegación.

if let navigationController = self.navigationController, navigationController.isBeingPresented {
    // being presented
}else{
    // being pushed
}

Si está utilizando ios 5.0 o posterior, utilice este código

-(BOOL)isPresented
{
    if ([self isBeingPresented]) {
        // being presented
         return YES;
    } else if ([self isMovingToParentViewController]) {
        // being pushed
         return NO;
    } else {
        // simply showing again because another VC was dismissed
         return NO;
    }
}

Swift 5
Esta práctica extensión maneja pocos casos más que las respuestas anteriores. Estos casos son VC (controlador de vista) es el VC raíz de la ventana de la aplicación, VC se agrega como VC secundario a primario. Intenta devolver verdadero solo si el viewcontroller se presenta modalmente.

extension UIViewController {
    /**
      returns true only if the viewcontroller is presented.
    */
    var isModal: Bool {
        if let index = navigationController?.viewControllers.firstIndex(of: self), index > 0 {
            return false
        } else if presentingViewController != nil {
            if let parent = parent, !(parent is UINavigationController || parent is UITabBarController) {
                return false
            }
            return true
        } else if let navController = navigationController, navController.presentingViewController?.presentedViewController == navController {
            return true
        } else if tabBarController?.presentingViewController is UITabBarController {
            return true
        }
        return false
    }
}

Gracias a la respuesta de Jonauz . Nuevamente hay espacio para más optimizaciones. Discuta sobre el caso que debe manejarse en la sección de comentarios.

Para alguien que se pregunta, Cómo decirle a ViewController que se está presentando

si Aestá presentando / empujandoB

1. Definir un enumy propertyenB

   enum ViewPresentationStyle {
       case Push
       case Present
   }
   
   //and write property 
   
   var vcPresentationStyle : ViewPresentationStyle = .Push //default value, considering that B is pushed 

2. Ahora en el Acontrolador de vista, diga Bsi se está presentando / empujando asignandopresentationStyle

   func presentBViewController() {
       let bViewController = B()
       bViewController.vcPresentationStyle = .Present //telling B that it is being presented
       self.presentViewController(bViewController, animated: true, completion: nil)
   }

3. Uso en el Bcontrolador de vista

   override func viewDidLoad() {
       super.viewDidLoad()
   
       if self.vcPresentationStyle == .Present {
           //is being presented 
       }
       else {
           //is being pushed
       }
   
   }

id presentedController = self.navigationController.modalViewController;
if (presentedController) {
     // Some view is Presented
} else {
     // Some view is Pushed
}

Esto le permitirá saber si viewController se presenta o se empuja