Comment vérifier si un contrôleur de vue est présenté de manière modale ou poussé sur une pile de navigation?

Comment puis-je, dans mon code de contrôleur de vue, faire la différence entre:

• présenté modalement
• poussé sur la pile de navigation

Les deux presentingViewControlleret isMovingToParentViewControllersont YESdans les deux cas, donc ne sont pas très utiles.

Ce qui complique les choses, c'est que mon contrôleur de vue parent est parfois modal, sur lequel le contrôleur de vue à vérifier est poussé.

Il s'avère que mon problème est que j'intègre mon HtmlViewControllerdans un UINavigationControllerqui est ensuite présenté. C'est pourquoi mes propres tentatives et les bonnes réponses ci-dessous n'ont pas fonctionné.

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

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

Je suppose que je ferais mieux de dire à mon contrôleur de vue quand il est modal, au lieu d'essayer de déterminer.

Prenez avec un grain de sel, n'a pas testé.

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

Dans Swift :

Ajoutez un indicateur pour tester s'il s'agit d'un modal par le type de classe:

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

Vous oublié un méthode: isBeingPresented.

isBeingPresented est vrai lorsque le contrôleur de vue est présenté et faux lorsqu'il est poussé.

- (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
Voici une solution qui résout le problème mentionné avec les réponses précédentes, lorsque les isModal()retours truesi poussés UIViewControllersont dans une UINavigationControllerpile présentée .

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

Cela fonctionne pour moi jusqu'à présent. Si quelques optimisations, merci de partager.

self.navigationController! = nil signifierait qu'il est dans une pile de navigation.

Afin de gérer le cas où le contrôleur de vue actuel est poussé alors que le contrôleur de navigation est présenté de manière modale, j'ai ajouté quelques lignes de code pour vérifier si le contrôleur de vue actuel est le contrôleur racine dans la pile de navigation.

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. Propre et simple.

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

Comme beaucoup de gens ici le suggèrent, que les méthodes de «vérification» ne fonctionnent pas bien dans tous les cas, dans mon projet, j'ai trouvé une solution pour gérer cela manuellement. Le fait est que nous gérons généralement nous-mêmes la présentation - ce n'est pas ce qui se passe dans les coulisses et nous devons introspecter.

DEViewController.h fichier:

#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

Les présentations pourraient maintenant être gérées de cette façon:

poussé sur la pile de navigation:

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

présenté modalement avec navigation:

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

présenté modalement:

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

En outre, dans DEViewControllernous pourrions ajouter une solution de secours à "vérifier" si la propriété susmentionnée est égale à 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;
    }
}

En supposant que tous les viewControllers que vous présentez de manière modale sont enveloppés dans un nouveau navigationController (ce que vous devriez toujours faire de toute façon), vous pouvez ajouter cette propriété à votre VC.

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

    return false
}

Pour détecter que votre contrôleur est poussé ou non, utilisez simplement le code ci-dessous où vous le souhaitez:

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

    // Not pushed
}
else {

    // Pushed
}

J'espère que ce code peut aider n'importe qui ...

self.navigationController != nil signifierait que c'est dans une pile de navigation.

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

Swift 5
Cette extension pratique gère quelques cas de plus que les réponses précédentes. Ces cas sont VC (contrôleur de vue) est le VC racine de la fenêtre d'application, VC est ajouté en tant qu'enfant au VC parent. Il essaie de renvoyer true uniquement si le viewcontroller est présenté de manière modale.

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

Merci à la réponse de Jonauz . Là encore, il y a de la place pour plus d'optimisations. Veuillez discuter du cas qui doit être traité dans la section des commentaires.

Si vous utilisez iOS 5.0 ou version ultérieure, veuillez utiliser ce code

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

Pour quelqu'un qui se demande, comment dire à ViewController qu'il est présenté

si Aprésente / pousseB

1. Définir un enumet propertydansB

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

2. Maintenant dans le Acontrôleur de vue, dites Bs'il est présenté / poussé en affectantpresentationStyle

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

3. Utilisation dans BView Controller

   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
}

Cela vous permettra de savoir si viewController est présenté ou poussé