iOS 6: Jak ograniczyć niektóre widoki do portretu i pozwolić innym na obracanie?

Mam aplikację na iPhone'a, która używa a UINavigationControllerdo prezentowania interfejsu szczegółowego: najpierw jeden widok, potem drugi, aż do czterech poziomów głębokości. Chcę, aby pierwsze trzy widoki były ograniczone do orientacji pionowej i tylko ostatni widok powinien mieć możliwość obrócenia do poziomu. Wracając z czwartego widoku do trzeciego, a czwarty widok był w orientacji poziomej, chcę, aby wszystko wróciło do pionu.

W iOS 5 po prostu zdefiniowałem shouldAutorotateToInterfaceOrientation:w każdym z moich kontrolerów widoku, aby zwracać TAK dla dopuszczalnych orientacji. Wszystko działało zgodnie z opisem powyżej, w tym powrót do portretu, nawet jeśli urządzenie było trzymane w orientacji poziomej podczas powrotu z kontrolera widoku # 4 do # 3.

W iOS 6 wszystkie kontrolery widoku obracają się do poziomu, łamiąc te, które nie były przeznaczone. W informacjach o wydaniu iOS 6 jest napisane

Większa odpowiedzialność przenosi się na aplikację i jej delegata. Teraz kontenery iOS (takie jak UINavigationController) nie konsultują się ze swoimi dziećmi w celu ustalenia, czy powinny one wykonywać autorotowanie. [...] System pyta najwyżej położony kontroler widoku pełnoekranowego (zwykle kontroler widoku głównego) o obsługiwane orientacje interfejsu za każdym razem, gdy urządzenie się obraca lub gdy kontroler widoku jest prezentowany w trybie prezentacji pełnoekranowej. Ponadto obsługiwane orientacje są pobierane tylko wtedy, gdy ten kontroler widoku zwraca wartość YES ze swojej shouldAutorotatemetody. [...] System określa, czy orientacja jest obsługiwana przez przecięcie wartości zwracanej przez supportedInterfaceOrientationsForWindow:metodę aplikacji z wartością zwracaną przez supportedInterfaceOrientationsmetodę najwyższego pełnoekranowego kontrolera.

Więc podklasowałem UINavigationController, nadałem mojej MainNavigationControllerwłaściwości boolowskiej landscapeOKi użyłem tego do zwrócenia dopuszczalnych orientacji w supportedInterfaceOrientations. Następnie w każdej z viewWillAppear:metod kontrolerów widoku mam taką linię

    [(MainNavigationController*)[self navigationController] setLandscapeOK:YES];

powiedzieć mojemu MainNavigationControllerpożądanemu zachowaniu.

Pojawia się pytanie: jeśli teraz przejdę do mojego czwartego widoku w trybie portretowym i obrócę telefon, obróci się on do poziomu. Teraz naciskam przycisk Wstecz, aby wrócić do mojego trzeciego widoku, który powinien być tylko portretem. Ale nie obraca się z powrotem. Jak mam to zrobić?

próbowałem

    [[UIApplication sharedApplication] setStatusBarOrientation:UIInterfaceOrientationPortrait]

w viewWillAppearmetodzie mojego trzeciego kontrolera widoku, ale nic nie robi. Czy to niewłaściwa metoda wywołania, czy może niewłaściwe miejsce, aby to wywołać, czy też powinienem zaimplementować całość w zupełnie inny sposób?

Miałem ten sam problem i znalazłem rozwiązanie, które działa dla mnie. Aby to zadziałało, nie wystarczy zaimplementować - (NSUInteger)supportedInterfaceOrientationsw UINavigationController. Musisz również zaimplementować tę metodę w kontrolerze # 3, który jest pierwszym, który ma być tylko portretowy po wystrzeleniu kontrolera # 4. Tak więc mam następujący kod w moim UINavigationController:

- (BOOL)shouldAutorotate
{
    return YES;
}

- (NSUInteger)supportedInterfaceOrientations
{
    if (self.isLandscapeOK) {
        // for iPhone, you could also return UIInterfaceOrientationMaskAllButUpsideDown
        return UIInterfaceOrientationMaskAll;
    }
    return UIInterfaceOrientationMaskPortrait;
}

W widoku kontrolera nr 3 dodaj następujące elementy:

- (NSUInteger)supportedInterfaceOrientations
{
    return UIInterfaceOrientationMaskPortrait;
}

Nie musisz niczego dodawać do swoich kontrolerów widoku nr 1, 2 i 4. To działa dla mnie, mam nadzieję, że ci pomoże.

Dodaj CustomNavigationController

Zastąp w nim te metody:

-(BOOL)shouldAutorotate
{
    return [[self.viewControllers lastObject] shouldAutorotate];
}

-(NSUInteger)supportedInterfaceOrientations
{
    return [[self.viewControllers lastObject] supportedInterfaceOrientations];
}

- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation
{
    return [[self.viewControllers lastObject] preferredInterfaceOrientationForPresentation];
}

Teraz dodaj wszystkie orientacje na liście

W kontrolerze widoku dodaj tylko te wymagane:

-(BOOL)shouldAutorotate
{
    return YES;
}

-(NSUInteger)supportedInterfaceOrientations
{
    return UIInterfaceOrientationMaskPortrait;
}

te metody zastępują metody kontrolera nawigacji

Po przejrzeniu każdej odpowiedzi w niezliczonych podobnych pytaniach dotyczących SO, żadna z odpowiedzi nie działała dla mnie, ale dali mi kilka pomysłów. Oto, jak ostatecznie rozwiązałem problem:

Najpierw upewnij się, że Obsługiwane orientacje interfejsu w miejscu docelowym projektu zawierają wszystkie orientacje, które chcesz dla widoku obrotowego.

Następnie utwórz kategorię UINavigationController(ponieważ Apple mówi, aby nie tworzyć podklasy):

@implementation UINavigationController (iOS6AutorotationFix)

-(BOOL)shouldAutorotate {
    return [self.topViewController shouldAutorotate];
}

@end

Zaimportuj tę kategorię i kontroler widoku, który chcesz mieć możliwość obracania (który będę wywoływać RotatingViewController) do kontrolera widoku najwyższego poziomu, który powinien zawierać kontroler nawigacji. W tym widoku kontroler zaimplementuj shouldAutorotatew następujący sposób. Zwróć uwagę, że nie powinien to być ten sam kontroler widoku, który chcesz obrócić.

-(BOOL)shouldAutorotate {

    BOOL shouldRotate = NO;

    if ([navigationController.topViewController isMemberOfClass:[RotatingViewController class]] ) {
        shouldRotate = [navigationController.topViewController shouldAutorotate];
    }

    return shouldRotate;
}

Wreszcie w swoim RotatingViewController, zaimplementuj shouldAutorotatei supportedInterfaceOrientationsw następujący sposób:

-(BOOL)shouldAutorotate {
    // Preparations to rotate view go here
    return YES;
}

-(NSUInteger)supportedInterfaceOrientations {
    return UIInterfaceOrientationMaskAllButUpsideDown; // or however you want to rotate
}

Powodem, dla którego musisz to zrobić, jest to, że iOS 6 daje kontrolę nad obrotem do głównego kontrolera widoku zamiast kontrolera widoku z góry. Jeśli chcesz, aby obrót pojedynczego widoku zachowywał się inaczej niż inne widoki w stosie, musisz napisać dla niego konkretny przypadek w głównym kontrolerze widoku.

Nie mam wystarczającej reputacji, aby skomentować odpowiedź @ Briana, więc dodam tutaj swoją notatkę.

Brian wspomniał, że iOS6 daje kontrolę rotacji do rootViewController - może to być nie tylko UINavigationController, jak wspomniano, ale także UITabBarController, którym był dla mnie. Moja struktura wygląda tak:

• UITabBarController
  • UINavigationController
    • UIViewControllers ...
  • UINavigationController
    • UIViewControllers ...

Dlatego dodałem metody najpierw w niestandardowym UITabBarController, następnie w niestandardowym UINavigationController, a na końcu w określonym UIViewController.

Przykład z UITabBarController i UINavigationController:

- (BOOL)shouldAutorotate {
    return [self.viewControllers.lastObject shouldAutorotate];
}

- (NSUInteger)supportedInterfaceOrientations {
    return [self.viewControllers.lastObject supportedInterfaceOrientations];
}

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation {
    return [self.viewControllers.lastObject shouldAutorotateToInterfaceOrientation:toInterfaceOrientation];
}

- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation {
    return [self.viewControllers.lastObject preferredInterfaceOrientationForPresentation];
}

Chciałbym udzielić częściowej odpowiedzi na moje własne pytanie. Znalazłem następujący wiersz kodu, użyty w viewWillAppearmetodzie mojej trzeciej UIViewController, działa:

[[UIDevice currentDevice] 
      performSelector:NSSelectorFromString(@"setOrientation:") 
           withObject:(id)UIInterfaceOrientationPortrait];

Ale nie podoba mi się to rozwiązanie. Wykorzystuje sztuczkę, aby przypisać właściwość tylko do odczytu, która zgodnie z dokumentacją Apple reprezentuje fizyczną orientację urządzenia. To tak, jakby powiedzieć iPhone'owi, aby przeskoczył do właściwej orientacji w dłoni użytkownika.

Kusi mnie, aby zostawić to w mojej aplikacji, ponieważ po prostu działa. Ale nie wydaje się to właściwe, więc chciałbym pozostawić pytanie otwarte, aby uzyskać czyste rozwiązanie.

To jest, którego używam do obsługi orientacji w iOS 6.0

-(BOOL)shouldAutorotate{
    return YES;
}  

 - (NSUInteger)supportedInterfaceOrientations{
    return UIInterfaceOrientationMaskAll;
}


- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation{  
  return UIInterfaceOrientationPortrait;
}

Ponieważ jest to bardzo popularny wątek. Pomyślałem, że dodam to, co uważam za najłatwiejszą odpowiedź. Działa to dla ios8 i nowszych

-(BOOL)shouldAutorotate
{
    return YES;
}

i

-(UIInterfaceOrientationMask)supportedInterfaceOrientations{
return UIInterfaceOrientationMaskPortrait;
}

Otóż ​​to. Cieszyć się!

Aha, i moje ViewControllery są osadzone w kontrolerze nawigacji, którego nie musiałem w żaden sposób tworzyć podklasy ani konfigurować.

To może nie działać dla wszystkich, ale dla mnie działa świetnie. Zamiast wdrażać ...

[(MainNavigationController*)[self navigationController] setLandscapeOK:YES];

in viewWillAppear we wszystkich moich kontrolerach, postanowiłem scentralizować ten proces w mojej podklasie UINavigationController, zastępując metodę UINavigationControllerDelegatenavigationController:willShowViewController:animated:

- (void)navigationController:(UINavigationController *)navigationController willShowViewController:(UIViewController *)viewController animated:(BOOL)animated {

    self.previousVCLandscapeOK = self.isLandscapeOK; // Store the current VC's orientation preference before pushing on the new VC so we can set this again from within the custom "back" method
    self.isLandscapeOK = NO; // Set NO as default for all VC's
    if ([viewController isKindOfClass:[YourViewController class]]) {
        self.isLandscapeOK = YES;
    }
}

Zauważyłem, że ta metoda delegata nie jest wywoływana podczas zdejmowania VC ze stosu nawigacyjnego. Nie stanowiło to dla mnie problemu, ponieważ obsługuję funkcję wsteczną z mojej podklasy UINavigationController, dzięki czemu mogę ustawić odpowiednie przyciski paska nawigacji i działania dla określonych VC, takich jak ten ...

if ([viewController isKindOfClass:[ShareViewController class]]) {

    UIButton* backButton = [[UIButton alloc] initWithFrame:CGRectMake(0, 0, 57, 30)];
    [backButton setImage:[UIImage imageNamed:@"back-arrow"] forState:UIControlStateNormal];
    [backButton addTarget:self action:@selector(back) forControlEvents:UIControlEventTouchUpInside];
    UIBarButtonItem* backButtonItem = [[UIBarButtonItem alloc] initWithCustomView:backButton];
    viewController.navigationItem.leftBarButtonItem = backButtonItem;

    UIImageView* shareTitle = [[UIImageView alloc] initWithImage:[UIImage imageNamed:@"share-title"]];
    [shareTitle setContentMode:UIViewContentModeScaleAspectFit];
    [shareTitle setFrame:CGRectMake(0, 0, shareTitle.frame.size.width - 10, shareTitle.frame.size.height - 10)];
    viewController.navigationItem.titleView = shareTitle;

} else if(...) {
    ...
}

Oto, backjak wygląda moja metoda, aby obsłużyć zdejmowanie VC ze stosu i ustawić odpowiednią preferencję rotacji ...

- (void)back {
    self.isLandscapeOK = self.previousVCLandscapeOK;
    self.previousVCLandscapeOK = NO;
    [self popViewControllerAnimated:YES];
}

Tak więc, jak widać, w zasadzie wszystko, co się dzieje, to najpierw ustawiam dwie właściwości ...

@property (nonatomic) BOOL isLandscapeOK;
@property (nonatomic) BOOL previousVCLandscapeOK;

w navigationController:willShowViewController:animated:którym określi obsługiwane orientacje w ramach tego VC, który ma zostać przedstawiony. Podczas wyskakiwania VC wywoływana jest moja niestandardowa metoda „wstecz”, a następnie ustawiam isLcapesOK na to, co zostało zapisane za pomocą poprzedniej wartości VCLcapesOK.

Jak powiedziałem, może to nie działać dla wszystkich, ale działa świetnie i nie muszę się martwić o dodanie kodu do każdego z moich kontrolerów widoku, udało mi się to wszystko scentralizować w podklasie UINavigationController.

Mam nadzieję, że to komuś pomoże, tak jak mnie. Dzięki, Jeremy.

Przejdź do pliku Info.plist i wprowadź zmianę

Chcesz wymusić portret aplikacji iOS 6 tylko wtedy możesz dodać poniższe metody do podklasy UIViewController

- (BOOL)shouldAutorotate {
    if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
        return YES;
    } else {
        return NO;
    }
}


- (NSUInteger)supportedInterfaceOrientations {
    if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
        return UIInterfaceOrientationMaskAll;
    } else {
        return UIInterfaceOrientationMaskPortrait;
    }
}

Chciałem, aby wszystkie moje VC były zablokowane w orientacji pionowej z wyjątkiem jednego. To mi się udało.

1. Dodaj obsługę wszystkich orientacji w pliku plist.

2. W głównym kontrolerze widoku wykryj rodzaj kontrolera widoku, który znajduje się w górnej części okna, i odpowiednio ustaw orientację aplikacji w metodzie supportedInterfaceOrientations . Na przykład potrzebowałem, aby moja aplikacja obracała się tylko wtedy, gdy widok sieciowy znajdował się na szczycie stosu. Oto, co dodałem w moim rootVC:

   -(NSUInteger)supportedInterfaceOrientations
   {
       UIViewController *topMostViewController = [[Utils getAppDelegate] appNavigationController].topViewController;
       if ([topMostViewController isKindOfClass:[SVWebViewController class]]) {
           return UIInterfaceOrientationMaskAllButUpsideDown;
       }
       return UIInterfaceOrientationMaskPortrait;
   }

Nie mam wystarczającej reputacji, aby odpowiedzieć na pytanie @Ram S pod odpowiedzią @micmdk, więc dodam tutaj swoją notatkę.

Kiedy używasz UITabbarController , spróbuj zmienić self.viewControllers.lastObject w kodzie @ micmdk na self.selectedViewController w następujący sposób:

- (BOOL)shouldAutorotate {
    return [self.selectedViewController shouldAutorotate];
}

- (NSUInteger)supportedInterfaceOrientations {
    return [self.selectedViewController supportedInterfaceOrientations];
}

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation {
    return [self.selectedViewController shouldAutorotateToInterfaceOrientation:toInterfaceOrientation];
}

- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation {
    return [self.selectedViewController preferredInterfaceOrientationForPresentation];
}

Możesz implementować i przesłonić shouldAutorotate () i obsługiwaneInterfaceOrientations var we wszystkich klasach kontrolera widoku, które powinny być prezentowane w innych orientacjach niż te zdefiniowane w PLIŚCIE Twojej aplikacji.

Jednak w nietrywialnym interfejsie użytkownika możesz napotkać problem z dodaniem go do dziesiątek klas i nie chcesz, aby wszystkie były podklasą kilku wspólnych, które go obsługują (MyBaseTableViewController, MyBaseNavigationController i MyBaseTabBarController).

Ponieważ nie można zastąpić tej metody / var bezpośrednio w UIViewController, możesz to zrobić na jego podklasach, które są zwykle twoimi klasami podstawowymi, takimi jak UITableViewController, UINavigationController i UITabBarController.

Możesz więc zaimplementować kilka rozszerzeń i nadal skonfigurować MyPreciousViewController, aby wyświetlał się w innych orientacjach niż wszystkie inne, takie jak ten fragment kodu Swift 4:

extension UITableViewController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {

    if let last = self.navigationController?.childViewControllers.last,
        last != self {
            return last.supportedInterfaceOrientations
    } else {
        return [.portrait]
    }
    }
}

extension MyPreciousViewController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {

    return [.portrait,.landscape]
    }
}


extension UINavigationController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {

        return [.portrait]
    }
}


extension UITabBarController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {

        return [.portrait]
    }
}

Rozwiązałem ten sam problem.

Jeśli używasz do UINavigationControllerprzekazywania kontrolerów widoku, musisz ustawić poniższe metody.

extension UINavigationController{

    override open var shouldAutorotate: Bool {

        if topViewController != nil && (topViewController?.isKind(of: LogInViewController.self))!
        {
            return true
        }
        return false
    }

    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {

        if topViewController != nil && (topViewController?.isKind(of: LogInViewController.self))!
        {
            return .portrait
        }
        return .landscapeRight

    }
    override open var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {

        if topViewController != nil && (topViewController?.isKind(of: LogInViewController.self))!
        {
            return .portrait
        }
        return .landscapeRight
    }
}

W miejscu LoginViewControllerwykorzystania, które UIViewControllerchcesz pokazać. W moim przypadku chcę pokazać LoginViewControllerw Portraittrybie innym ViewControllersw landscapetrybie.

Aby rozwiązać ten problem, użyj następującej metody

- (NSUInteger)supportedInterfaceOrientations
{
    return UIInterfaceOrientationMaskPortrait;
}

zwróć tylko wybraną orientację !!!