Jak sprawdzić, czy kontroler widoku jest prezentowany modalnie lub wypychany na stosie nawigacyjnym?

Jak w kodzie kontrolera widoku mogę rozróżnić:

• prezentowane modalnie
• na stosie nawigacyjnym

Obie presentingViewControlleri isMovingToParentViewControllersą YESw obu przypadkach, więc nie są zbyt pomocne.

To, co komplikuje sprawę, to fakt, że mój nadrzędny kontroler widoku jest czasami modalny, na który wpychany jest kontroler widoku do sprawdzenia.

Okazuje się, że moim problemem jest to, że osadzam mój HtmlViewControllerplik, UINavigationControllerktóry jest następnie prezentowany. Dlatego moje własne próby i poniższe dobre odpowiedzi nie działały.

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

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

Wydaje mi się, że lepiej byłoby powiedzieć mojemu kontrolerowi widoku, kiedy jest modalny, zamiast próbować określić.

Weź z przymrużeniem oka, nie testowałem.

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

W Swift :

Dodaj flagę, aby sprawdzić, czy jest modalna według typu klasy:

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

Państwo pominąć jedną metodę: isBeingPresented.

isBeingPresented jest prawdziwe, gdy kontroler widoku jest prezentowany i fałszywy, gdy jest wypychany.

- (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
Oto rozwiązanie, które rozwiązuje problem wspomniany w poprzednich odpowiedziach, kiedy isModal()zwraca, truejeśli push UIViewControllerjest w prezentowanym UINavigationControllerstosie.

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

Jak na razie to działa. Jeśli jakieś optymalizacje, udostępnij.

self.navigationController! = nil oznaczałoby, że znajduje się w stosie nawigacyjnym.

Aby obsłużyć przypadek, w którym bieżący kontroler widoku jest wypychany, podczas gdy kontroler nawigacji jest prezentowany modalnie, dodałem kilka wierszy kodu, aby sprawdzić, czy bieżący kontroler widoku jest kontrolerem głównym w stosie nawigacji.

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

Szybki 4

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

Swift 5. Czysty i prosty.

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

Jak wielu ludzi tutaj sugeruje, że metody „sprawdzania” nie działają dobrze we wszystkich przypadkach, w moim projekcie wymyśliłem rozwiązanie umożliwiające ręczne zarządzanie. Chodzi o to, że zwykle zarządzamy prezentacją samodzielnie - to nie jest to, co dzieje się za kulisami i musimy introspekować.

DEViewController.h plik:

#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

Prezentacje można teraz zarządzać w ten sposób:

na stosie nawigacyjnym:

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

prezentowane modalnie z nawigacją:

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

przedstawione modalnie:

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

Również w DEViewControllermoglibyśmy dodać funkcję powrotu do „sprawdzenia” czy wspomniana nieruchomość jest równa 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;
    }
}

Zakładając, że wszystkie viewControllery, które prezentujesz modalnie, są opakowane w nowy navigationController (co i tak zawsze powinieneś robić), możesz dodać tę właściwość do swojego VC.

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

    return false
}

Aby wykryć, że kontroler jest wciśnięty lub nie wystarczy użyć poniższego kodu w dowolnym miejscu:

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

    // Not pushed
}
else {

    // Pushed
}

Mam nadzieję, że ten kod może pomóc każdemu ...

self.navigationController != nil oznaczałoby, że jest w stosie nawigacyjnym.

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

Swift 5
To poręczne rozszerzenie obsługuje kilka przypadków więcej niż poprzednie odpowiedzi. Te przypadki to VC (kontroler widoku), który jest głównym VC okna aplikacji, VC jest dodawany jako dziecko do nadrzędnego VC. Próbuje zwrócić prawdę tylko wtedy, gdy kontroler widoku jest przedstawiony modalnie.

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

Dzięki odpowiedzi Jonauza . Znowu jest miejsce na więcej optymalizacji. Prosimy o omówienie sprawy, którą należy załatwić w sekcji komentarzy.

Jeśli używasz ios 5.0 lub nowszego, użyj tego kodu

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

Dla kogoś, kto się zastanawia, jak powiedzieć ViewController, że jest prezentowany

jeśli Aprezentuje / pchaB

1. Zdefiniuj enumi propertywB

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

2. Teraz w Awidoku kontrolera powiedz, Bczy jest prezentowany / popychany, przypisującpresentationStyle

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

3. Użycie w Bkontrolerze widoku

   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
}

Dzięki temu wiesz, czy viewController jest prezentowany czy wypychany