iOS 6: ¿Cómo puedo restringir algunas vistas al retrato y permitir que otras giren?

Tengo una aplicación para iPhone que usa un UINavigationControllerpara presentar una interfaz de desglose: primero una vista, luego otra, hasta cuatro niveles de profundidad. Quiero que las primeras tres vistas se restrinjan a la orientación vertical y solo se debe permitir que la última vista gire a horizontal. Cuando regrese de la cuarta vista a la tercera y la cuarta vista estaba en orientación horizontal, quiero que todo gire de nuevo a retrato.

En iOS 5, simplemente definí shouldAutorotateToInterfaceOrientation:en cada uno de mis controladores de vista para devolver SÍ para las orientaciones permitidas. Todo funcionó como se describió anteriormente, incluido el regreso al retrato incluso si el dispositivo se mantenía en orientación horizontal al regresar del controlador de vista # 4 al # 3.

En iOS 6, todos los controladores de vista giran a paisaje, rompiendo aquellos que no estaban destinados a hacerlo. Las notas de la versión de iOS 6 dicen

Se está trasladando más responsabilidad a la aplicación y al delegado de la aplicación. Ahora, los contenedores de iOS (como UINavigationController) no consultan a sus hijos para determinar si deben rotar automáticamente. [...] El sistema solicita al controlador de vista de pantalla completa superior (generalmente el controlador de vista raíz) sus orientaciones de interfaz compatibles cada vez que el dispositivo gira o siempre que se presenta un controlador de vista con el estilo de presentación modal de pantalla completa. Además, las orientaciones admitidas se recuperan solo si este controlador de vista devuelve YES de su shouldAutorotatemétodo. [...] El sistema determina si una orientación es compatible mediante la intersección del valor devuelto por el supportedInterfaceOrientationsForWindow:método de la aplicación con el valor devuelto por el supportedInterfaceOrientationsmétodo del controlador de pantalla completa superior.

Así que hice una subclase UINavigationController, le di a mi MainNavigationControlleruna propiedad booleana landscapeOKy la usé para devolver las orientaciones permitidas en supportedInterfaceOrientations. Luego, en cada uno de los viewWillAppear:métodos de mis controladores de vista , tengo una línea como esta

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

para decirle a mi MainNavigationControllerel comportamiento deseado.

Aquí viene la pregunta: si ahora navego a mi cuarta vista en modo vertical y doy la vuelta al teléfono, gira a horizontal. Ahora presiono el botón Atrás para regresar a mi tercera vista, que se supone que funciona solo en retrato. Pero no gira hacia atrás. ¿Cómo hago para que haga eso?

Lo intenté

    [[UIApplication sharedApplication] setStatusBarOrientation:UIInterfaceOrientationPortrait]

en el viewWillAppearmétodo de mi tercer controlador de vista, pero no hace nada. ¿Es este el método incorrecto para llamar o tal vez el lugar incorrecto para llamarlo o debería implementar todo de una manera totalmente diferente?

Tuve el mismo problema y encontré una solución que funciona para mí. Para que funcione, es no suficiente para aplicar - (NSUInteger)supportedInterfaceOrientationsen su UINavigationController. También debe implementar este método en su controlador n. ° 3, que es el primero en ser solo vertical después de hacer estallar el controlador n. ° 4. Entonces, tengo el siguiente código en mi UINavigationController:

- (BOOL)shouldAutorotate
{
    return YES;
}

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

En la vista del controlador n. ° 3, agregue lo siguiente:

- (NSUInteger)supportedInterfaceOrientations
{
    return UIInterfaceOrientationMaskPortrait;
}

No es necesario que agregue nada a los controladores de vista n. ° 1, n. ° 2 y n. ° 4. Esto funciona para mí, espero que te ayude.

Agregar un CustomNavigationController

Anula estos métodos en él:

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

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

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

Ahora agregue todas las orientaciones en el plist

En el controlador de vista agregue solo los requeridos:

-(BOOL)shouldAutorotate
{
    return YES;
}

-(NSUInteger)supportedInterfaceOrientations
{
    return UIInterfaceOrientationMaskPortrait;
}

estos métodos anulan los métodos del controlador de navegación

Después de revisar cada respuesta en innumerables preguntas similares sobre SO, ninguna de las respuestas funcionó para mí, pero me dieron algunas ideas. Así es como terminé resolviendo el problema:

Primero, asegúrese de que las Orientaciones de interfaz admitidas en el objetivo de su proyecto contengan todas las orientaciones que desea para su vista giratoria.

A continuación, cree una categoría de UINavigationController(ya que Apple dice que no se subclasifique):

@implementation UINavigationController (iOS6AutorotationFix)

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

@end

Importe esa categoría y el controlador de vista que desea poder rotar (al que llamaré RotatingViewController) a su controlador de vista de nivel más alto, que debe contener su controlador de navegación. En ese controlador de vista, implemente de la shouldAutorotatesiguiente manera. Tenga en cuenta que este no debería ser el mismo controlador de vista que desea rotar.

-(BOOL)shouldAutorotate {

    BOOL shouldRotate = NO;

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

    return shouldRotate;
}

Finalmente, en su RotatingViewController, implemente shouldAutorotatey de la supportedInterfaceOrientationssiguiente manera:

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

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

La razón por la que necesita hacer esto es porque iOS 6 le da control de rotación al controlador de vista raíz en lugar del controlador de vista superior. Si desea que la rotación de una vista individual se comporte de manera diferente a otras vistas en la pila, debe escribir un caso específico para ella en el controlador de vista raíz.

No tengo suficiente reputación para comentar la respuesta de @ Brian, así que agregaré mi nota aquí.

Brian mencionó que iOS6 le da el control de rotación al rootViewController; esto no solo podría ser un UINavigationController como se mencionó, sino también un UITabBarController, que era para mí. Mi estructura se ve así:

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

Así que agregué los métodos primero en un UITabBarController personalizado, luego en un UINavigationController personalizado y finalmente en el UIViewController específico.

Ejemplo de UITabBarController y 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];
}

Me gustaría dar una respuesta parcial a mi propia pregunta. Encontré la siguiente línea de código, utilizada en el viewWillAppearmétodo de mi tercero UIViewController, para funcionar:

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

Pero realmente no me gusta esta solución. Utiliza un truco para asignar una propiedad de solo lectura que, según la documentación de Apple, representa la orientación física del dispositivo. Es como decirle al iPhone que salte a la orientación correcta en la mano del usuario.

Estoy muy tentado a dejar esto en mi aplicación, ya que simplemente funciona. Pero no se siente bien, así que me gustaría dejar la pregunta abierta para una solución clara.

Esto es lo que estoy usando para soporte de orientación en ios 6.0

-(BOOL)shouldAutorotate{
    return YES;
}  

 - (NSUInteger)supportedInterfaceOrientations{
    return UIInterfaceOrientationMaskAll;
}


- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation{  
  return UIInterfaceOrientationPortrait;
}

Siendo que este es un hilo muy visto. Pensé que agregaría lo que creo que es la respuesta más fácil. Esto funciona para ios8 y posteriores

-(BOOL)shouldAutorotate
{
    return YES;
}

y

-(UIInterfaceOrientationMask)supportedInterfaceOrientations{
return UIInterfaceOrientationMaskPortrait;
}

Eso es. ¡Disfrutar!

Ah, y mis ViewControllers están integrados en un controlador de navegación, que no necesitaba subclasificar ni configurar de ninguna manera.

Puede que esto no funcione para todos, pero funciona muy bien para mí. En lugar de implementar ...

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

en viewWillAppear en todos mis controladores, decidí centralizar este proceso dentro de mi subclase UINavigationController anulando el método 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;
    }
}

Descubrí que este método de delegado no se llama al sacar un VC de la pila de navegación. Esto no fue un problema para mí porque estoy manejando la funcionalidad de retroceso desde mi subclase UINavigationController para que pueda configurar los botones y acciones de la barra de navegación adecuados para VC específicos como este ...

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(...) {
    ...
}

Así es backcomo se ve mi método para manejar la extracción del VC de la pila y establecer la preferencia de rotación adecuada ...

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

Entonces, como puede ver, básicamente todo lo que está sucediendo es que primero me estoy configurando dos propiedades ...

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

en el navigationController:willShowViewController:animated:cual se determinarán cuáles son las orientaciones soportadas dentro de esa CV que está a punto de ser presentada. Al abrir un VC, se llama a mi método personalizado "back" y luego estoy configurando isLandscapeOK a lo que se almacenó a través del valor VCLandscapeOK anterior.

Como dije, esto puede no funcionar para todos, pero funciona muy bien para mí y no tengo que preocuparme por agregar código a cada uno de mis controladores de vista, pude mantenerlo todo centralizado en la subclase UINavigationController.

Espero que esto ayude a alguien como a mí. Gracias Jeremy.

Vaya a su archivo Info.plist y realice el cambio

Solo desea Forzar el retrato de la aplicación iOS 6 y luego puede agregar a una subclase de UIViewController a continuación los métodos

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

Quería tener todos mis VC bloqueados en orientación vertical excepto uno. Esto es lo que funcionó para mí.

1. Agregue soporte para todas las orientaciones en el archivo plist.

2. En el controlador de vista raíz, detecte el tipo de controlador de vista que está en la parte superior de la ventana y establezca la orientación de la aplicación en consecuencia en el método supportedInterfaceOrientations . Por ejemplo, necesitaba que mi aplicación girara solo cuando la vista web estaba en la parte superior de la pila. Esto es lo que agregué en mi rootVC:

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

No tengo suficiente reputación para responder la pregunta de @Ram S en la respuesta de @micmdk, así que agregaré mi nota aquí.

Cuando use UITabbarController , intente cambiar self.viewControllers.lastObject en el código de @ micmdk a self.selectedViewController así:

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

Puede implementar y anular shouldAutorotate () y supportedInterfaceOrientations var en todas sus clases de View Controller que deben presentarse en orientaciones diferentes a las definidas en PLIST de su aplicación.

Sin embargo, en una interfaz de usuario no trivial, es posible que tenga un problema para agregarlo en docenas de clases y no desea que todas sean subclase de varios comunes que lo admiten (MyBaseTableViewController, MyBaseNavigationController y MyBaseTabBarController).

Dado que no puede anular esos métodos / var en UIViewController directamente, puede hacerlo en sus subclases que generalmente son clases base suyas como UITableViewController, UINavigationController y UITabBarController.

Por lo tanto, puede implementar algunas extensiones y aún configurar MyPreciousViewController para que se muestre en orientaciones diferentes a todas las demás, como este fragmento de código 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]
    }
}

He resuelto el mismo tipo de problema.

Si está utilizando UINavigationControllerpara empujar los controladores de vista, debe configurar los métodos a continuación.

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

En el lugar de LoginViewControlleruso que UIViewControllerdesea mostrar. En mi caso, quiero mostrar el LoginViewControlleren el Portraitmodo otro ViewControllersen el landscapemodo.

Utilice el siguiente método para resolver este problema

- (NSUInteger)supportedInterfaceOrientations
{
    return UIInterfaceOrientationMaskPortrait;
}

devuelve solo la orientación que quieras !!!