Estoy usando MGSplitViewController y estoy usandoshouldAutorotateToInterfaceOrientation para controlar el tamaño de la vista principal de la controladora en la rotación.

Todo trabaja bien en iOS 5, pero en iOS 6 (ambos simulador y iPad) shouldAutorotateToInterfaceOrientation nunca es llamado.

Es esto un error que debo esperar a ser corregido con la versión final de iOS 6 o algo que yo no soy consciente de que ha cambiado?

17 Comentarios

  1. 128

    Por FAVOR LEA esto CUIDADOSAMENTE o usted podría perder 1-2 días de su vida con ir a lo loco y de lucha, temblores, girando el dispositivo de prueba como la del chimpancé en el zoológico que agarró un visitante de un móvil! Más pronto o más tarde…prometo 🙂

    EN iOS 6

    shouldAutorotateToInterfaceOrientation:

    es obsoleto y ha sido sustituido por

    shouldAutorotate

    significa iOS 6 va a llamar nunca shouldAutorotateToInterfaceOrientation:

    así que si usted utiliza el siguiente en su aplicación

    ANTES de iOS6 (iOS5,iOS4, etc.)

    - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
    {
    if (interfaceOrientation == UIInterfaceOrientationPortrait) {
    //your code for portrait mode
    
    }
    
    return YES;
    }

    debe utilizar

    DESPUÉS de iOS 6+

    - (BOOL)shouldAutorotate {
    
    UIInterfaceOrientation orientation = [[UIApplication sharedApplication] statusBarOrientation];
    
    if (orientation == UIInterfaceOrientationPortrait) {
    //your code for portrait mode
    
    }
    
    return YES;
    }

    SER CONSCIENTES DE

    UIInterfaceOrientation es una propiedad de UIApplication y sólo contiene 4 posibilidades que corresponden a la orientación de la barra de estado:

    UIInterfaceOrientationPortrait = UIDeviceOrientationPortrait,
    
    UIInterfaceOrientationPortraitUpsideDown = UIDeviceOrientationPortraitUpsideDown,
    
    UIInterfaceOrientationLandscapeLeft = UIDeviceOrientationLandscapeRight,
    
    UIInterfaceOrientationLandscapeRight = UIDeviceOrientationLandscapeLeft

    NO HAY QUE CONFUNDIRLO CON

    UIDeviceOrientation que es una propiedad de la UIDevice clase, y contiene 7 valores posibles:

    UIDeviceOrientationUnknown - Can not be determined
    
    UIDeviceOrientationPortrait - Home button facing down
    
    UIDeviceOrientationPortraitUpsideDown - Home button facing up
    
    UIDeviceOrientationLandscapeLeft - Home button facing right
    
    UIDeviceOrientationLandscapeRight - Home button facing left
    
    UIDeviceOrientationFaceUp - Device is flat, with screen facing up
    
    UIDeviceOrientationFaceDown - Device is flat, with screen facing down

    incluso puede teóricamente UIDeviceOrientation orientation = [[UIDevice currentDevice] orientation]; que devuelve UIDeviceOrientation – el dispositivo de orientación real – PERO tienes que saber que UIDeviceOrientation no es siempre igual UIInterfaceOrientation!!! Por ejemplo, cuando el dispositivo está en una mesa plana puede recibir valor inesperado.

    Puede utilizar UIInterfaceOrientation orientation = self.interfaceOrientation; demasiado que devuelve UIInterfaceOrientation, la orientación actual de la interfaz, PERO es una propiedad de la UIViewController, así que usted puede acceder a este solo en UIViewController clases.

    Si te gustaría apoyar tanto antes de iOS6 (iOS3/4/5) y dispositivos iOS6 – que podría ser evidente – sólo tiene que utilizar tanto shouldAutorotateToInterfaceOrientation: y shouldAutorotate en el código.

    De iOS 6 hay 3 niveles y 3 pasos que el dispositivo de control durante el inicio de la aplicación, que tienes que controlar si quieres.

    1. Info.plist - Supported Interface Orientations

    que podría definir gráficamente en la ficha Resumen. La secuencia de orientaciones es IMPORTANTE, que puede cambiar de forma manual mediante la edición de la info.plist, y el dispositivo que se elija la primera cuando la aplicación está lanzando! Esto es crítico, ya que el problema siempre es el lanzamiento de la app cuando existe la posibilidad de que el [UIDevice currentDevice].orientation es desconocido, especialmente cuando ponemos a prueba nuestra aplicación en una superficie plana.

    shouldAutorotateToInterfaceOrientation no se llama en iOS 6

    SER CONSCIENTES DE
    Hay otras dos opciones con posibilidad (iPad) o (iPhone) de extensión, si se utiliza cualquiera de ellos, que va a utilizar esa configuración del dispositivo actual o simulador y el abandono de la configuración general sin la extensión. Así que si usted tiene un iPhone sólo de la aplicación y, accidentalmente, le dejó una «Interfaz Compatible con Orientaciones (iPad)» de la línea en algún lugar en el plist incluso sin ningún tipo de datos, es el abandono de las reglas que se han establecido anteriormente en la configuración general (en mi ejemplo para iPhone) y usted podría conseguir un rechazo para su Aplicación con un texto «Hemos encontrado que la aplicación no cumplen los requisitos para ejecutarse en el iPad…» incluso si la aplicación no tiene la intención de utilizar una determinada orientación en el iPhone, pero el iPad va a usar lo que podría causar imprevistos y errores, como todas las aplicaciones para el iPhone que tiene que ejecutar en el iPad también durante el proceso de envío.

    2. AppDelegate - application:supportedInterfaceOrientationsForWindow

    de regresar de una máscara de bits listado de todas las orientaciones desea permitir, que anulan la info.plist configuración.Esto se denomina al menos una vez por todas las veces que el dispositivo gira.

    3. Top-level view controller or RootViewController - supportedInterfaceOrientations

    que da una intersección con el conjunto de la app y app delegado, que no son resultado de cero para evitar el accidente. Esto se denomina al menos una vez por todas las veces que el dispositivo gira, excepto que hay un otro método instalado en nuestro controlador:

    shouldAutorotate

    que interfiere con la aplicación permite orientaciones, y le da un BOOL con defecto YES.

    BE CAREFUL when you use `NavigationController`

    como el primer controlador en su AppDelegate, como este:

    DetailViewController *detailViewController = [[DetailViewController alloc] initWithNibName:@"DetailViewController" bundle:nil];
    UINavigationController *navigationController=[[UINavigationController alloc] initWithRootViewController:detailViewController];
    self.window.rootViewController =nil;
    self.window.rootViewController = navigationController;
    [self.window makeKeyAndVisible];
    return YES;

    en este caso, usted tiene que colocar el siguiente código en su AppDelegate como una categoría de apego a NavigationController clase, ya que este es el primer controlador, y si usted no ha hecho una subcategoría de la misma, usted no tiene ningún lugar/código donde puede establecer su configuración de orientación, por lo que necesita de la fuerza para verificar su real rootViewController en este caso el detailViewController las orientaciones:

    @implementation UINavigationController (OrientationSettings_IOS6)
    
    -(BOOL)shouldAutorotate {
    return [[self.viewControllers lastObject] shouldAutorotate];
    }
    
    -(NSUInteger)supportedInterfaceOrientations {
    return [[self.viewControllers lastObject] supportedInterfaceOrientations];
    }
    
    - (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation {
    return [[self.viewControllers lastObject] preferredInterfaceOrientationForPresentation];
    }
    
    @end

    después de esto usted puede establecer las orientaciones preferidas en su «superior» ViewController (en mi ejemplo de esto es el detailViewController) con cualquiera de los métodos disponibles en iOS 6 para ViewControllers, como a continuación:

    1. (BOOL)shouldAutorotate
    
    2. (NSUInteger)supportedInterfaceOrientations
    
    3. (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation
    • en el último ejemplo lo que es el OrientationSettings_IOS6 en @ejecución UINavigationController (OrientationSettings_IOS6)
    • Es una definición de categoría, se puede utilizar cualquier tipo de nombre, es arbitraria. Con el uso de la categoría, se podría adjuntar los métodos de otras clases, especialmente si usted no pudo llegar o editar el .m archivo. Útil fenómeno de verificación en la literatura.
    • Leí esto y me entran ganas de llorar.
    • A mí me funcionó, gracias.
    • su forma de explicación es agradable +100 votos
  2. 55

    Ok, yo tengo que trabajar en iOS6 iPad Simulator. Yay. Esto es lo que hice:

    Me acaba de mostrar el antes y el después, que se explica por sí mismo:

    ANTES de

    - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
    
    if (interfaceOrientation==UIInterfaceOrientationPortrait) {
     //do some sh!t
    
    }
    
    return YES;
    }

    DESPUÉS de

    - (BOOL)shouldAutorotate {
    
    UIInterfaceOrientation orientation = [[UIDevice currentDevice] orientation];
    
    if (orientation==UIInterfaceOrientationPortrait) {
     //do some sh!t
    
    }
    
    return YES;
    }

    Como para la orientación compatible, se puede especificar en la información.plist como tal:
    shouldAutorotateToInterfaceOrientation no se llama en iOS 6

    O utilice el código:

    -(NSUInteger)supportedInterfaceOrientations{
        return UIInterfaceOrientationMaskPortrait; //etc
    }

    Edit: pensándolo bien, si el plan de apoyo a versiones inferiores (iOS4.3/5/5.1) así como 6.0, a continuación, sólo tienes que incluir ambos métodos con el mismo código de contenido. A mí me funciona (en el sim de todos modos)

    • No estoy seguro sobre el uso de [[UIDevice currentDevice] orientation]UIDeviceOrientation no es la misma cosa como UIInterfaceOrientation.
    • Parece que son el mismo.
    • Sólo en caso de que nadie quiere leer mi post de abajo, por favor sea consciente de que el dispositivo no puede saber es la orientación en la creación de inicio de la aplicación. Como tal, puede que también desee comprobar en contra de if (orientation == UIDeviceOrientationUnknown)
    • 2 líneas de código vale más que 1000 palabras 😛
  3. 20

    Configuración de la ventana de la aplicación de la ruta de la controladora, en lugar de, simplemente agregar es vista como una subvista trabajado para mí (como Rocotilos hizo)

    //   [self.window addSubview:self.topLevelNavigationController.view];
    self.window.rootViewController = self.topLevelNavigationController;
    • Esto no funciona en iOS 6. Intente lo siguiente: Crear un nuevo proyecto de XCode y elegir la plantilla Single View Application. La plantilla del AppDelegate ya contiene la línea en la que estamos sugiriendo. A continuación, reemplazar shouldAutorotateToInterfaceOrientation en el ViewController, establecer un punto de interrupción y depurar. El punto de corte que nunca va a ser un hit (iOS 6).
  4. 18

    He aquí una solución para iOS 5 y versiones anteriores de código que no se trata de la duplicación de la lógica. Simplemente agregue este código al controlador de vista y genera el supportedInterfaceOrientations de su shouldAutorotateToInterfaceOrientation método.

    -(BOOL)shouldAutorotate{
        return YES;
    }
    
    -(NSInteger)supportedInterfaceOrientations{
    NSInteger mask = 0;
    if ([self shouldAutorotateToInterfaceOrientation: UIInterfaceOrientationLandscapeRight])
        mask |= UIInterfaceOrientationMaskLandscapeRight;
    if ([self shouldAutorotateToInterfaceOrientation: UIInterfaceOrientationLandscapeLeft])
        mask |= UIInterfaceOrientationMaskLandscapeLeft;
    if ([self shouldAutorotateToInterfaceOrientation: UIInterfaceOrientationPortrait])
        mask |= UIInterfaceOrientationMaskPortrait;
    if ([self shouldAutorotateToInterfaceOrientation: UIInterfaceOrientationPortraitUpsideDown])
        mask |= UIInterfaceOrientationMaskPortraitUpsideDown;
    return mask;
    }
    • Esto es una buena idea. Si bien creo que no es tan difícil, sólo la creación de una aplicación para el nuevo método, en la mayoría de las situaciones, usted todavía tiene un voto, ya que esta puede ser la mejor solución cuando se tiene una única subclase de UIViewController que se utilizan como base para todos sus controladores.
    • Echa un vistazo un poco más elegante solución
    • Esta NO es la respuesta correcta. Si usted tiene una lógica específica construido para digamos UIInterfaceOrientationPortraitUp este código no hace nada, pero camina a través de toda la dirección y sigue llamando shouldAutorotateToInterfaceOrientation una y otra vez
    • Brillante solución
  5. 15

    Una solución rápida para mí fue añadir este código en mi raíz controlador de vista de

    - (BOOL)shouldAutorotate {
        return [self shouldAutorotateToInterfaceOrientation:self.interfaceOrientation];
    }

    De esta manera puedo usar la misma lógica que se utiliza para las versiones anteriores a iOS 6. Por supuesto, que originalmente se había establecido mi rootViewController en mi aplicación a los delegados didFinishLaunchingWithOptions adecuadamente en lugar de simplemente añadiendo a la de windows subvistas.

    • Pero de nuevo, este método es depreciado..a la Derecha?
    • Bueno, shouldAutorotate no es obsoleto, pero shouldAutorotateToInterfaceOrientation es. Sin embargo, eso sólo significa que el sistema operativo no llame más. Si se ha implementado y funciona a la que puede llamar gratis a la misma. No es obsoleto para usted. Por supuesto, esto es referente a los cambios en ios 6.
    • shouldAutorotateToInterfaceOrientation está en desuso en iOS6
    • Obsoleto significa que la función ya no es compatible y puede ser eliminada en el futuro. Si usted quiere que sus apps para sobrevivir a las actualizaciones, no uso de funciones obsoletas.
    • shouldAutorotate no es obsoleto. Realmente impresionante la solución, la única solución que trabajó conmigo
    • Me gustaría, personalmente, el viejo método de llamada de uno nuevo en lugar de a la inversa, pero eso es sólo conmigo. La gente, el tránsito de estado de el viejo método no debe importar cuando las implementaciones es su propio.
    • A partir de la documentación: interfaceOrientation: la Conveniencia de la propiedad que proporciona la orientación actual de la interfaz, útil sólo si el controlador de vista está ocupando la pantalla completa. No utilice esta propiedad para informar las decisiones de diseño. En su lugar, utilice el statusBarOrientation de la propiedad.

  6. 11

    Y mientras que un número de las respuestas que tiene la solución indicada — que ser para implementar shouldAutorotate y supportedInterfaceOrientations para iOS 6 se basa — también debe ser consciente de que si su controlador de vista es alojado en un navigation controller, nada de eso importa ya que el tiempo de ejecución de llamar a estos en el UINavigationController instancia e ignorar el código de otro modo.

    Al parecer, la ‘solución’ es subclase UINavigationController la aplicación de estos nuevos métodos en esta sub-clase como se describe aquí:
    iOS 6 UITabBarController orientación compatible con la actual UINavigation controlador

    Y, a continuación, usted tiene el placer de cambiar todo el código donde se use un UINavigationController para el uso de esta nueva sub-clase en su lugar.

    Este tiene que ser uno de los más inútil y molesto de la ruptura de los cambios en iOS versión que he visto nunca.

  7. 10

    IOS 5

    - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation{
    if (UIInterfaceOrientationLandscapeLeft) {
            return (interfaceOrientation == UIInterfaceOrientationLandscapeLeft);
        }
        if (UIInterfaceOrientationLandscapeRight) {
            return (interfaceOrientation == UIInterfaceOrientationLandscapeRight);
        }
        return (interfaceOrientation == UIInterfaceOrientationLandscapeLeft);
    }

    IOS 6

    -(BOOL)shouldAutorotate{
        return YES;
    }
    
    -(NSInteger)supportedInterfaceOrientations:(UIWindow *)window{
    
        //   UIInterfaceOrientationMaskLandscape;
        //   24
        //
        //   UIInterfaceOrientationMaskLandscapeLeft;
        //   16
        //
        //   UIInterfaceOrientationMaskLandscapeRight;
        //   8
        //
        //   UIInterfaceOrientationMaskPortrait;
        //   2
    
    
        //   return UIInterfaceOrientationMaskLandscape;
        return 24;
    }
    • Use || operadores en lugar de los números de magia. Esto hará que sea mucho más fácil de leer!
    • O UIInterfaceOrientationMaskAllButupsidedown.
    • NSInteger espera un número.
    • Creo supportedInterfaceOrientations:(UIWindow *)de la ventana debe ser supportedInterfaceOrientations.
  8. 3

    Esto funcionó para mí con iOS6 y Xcode 4.5 GM:

    Sobre AppDelegate.m

    - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
    {
        .....
    
        //  self.window.rootViewController = self.navigationController;
    
        [window setRootViewController:navigationController];
    
        .....
    
        return YES;
    }

    sobre ViewController:

    - (void)willAnimateRotationToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation duration:(NSTimeInterval)duration
    
    {
        if (UIInterfaceOrientationIsLandscape(interfaceOrientation))
    
        {
          //landscape
        }
        else
        {
          //portrait
        }
    }
  9. 3

    He aquí una cita de Apple iOS SDK, XCode4.5+ (ver UIViewController de Referencia de la Clase, el Manejo de Vista de Rotaciones):

    De iOS 6, su aplicación es compatible con la interfaz de las orientaciones definidas en la aplicación de la Información.plist archivo. Un controlador de vista puede reemplazar el supportedInterfaceOrientations método para limitar la lista de las orientaciones. En general, el sistema llama a este método sólo en la raíz de controlador de vista de la ventana o un controlador de vista presentados para llenar la pantalla completa; hijo de la vista uso de controladores de la parte de la ventana proporcionada por ellos, por sus padres controlador de vista y ya no participan directamente en la toma de decisiones acerca de lo que las rotaciones son compatibles.

    También en iOS6, shouldAutorotateToInterfaceOrientation: método de UIViewController clase ya está en desuso.

    Por lo que en su raíz controlador de vista, el ff:

    - (BOOL)shouldAutorotate {
      return YES;
    }
    
    - (NSUInteger)supportedInterfaceOrientations {
      return UIInterfaceOrientationMaskPortrait;
    }

    Por cierto, «la raíz de controlador de vista» es cualquier UIViewController subclase se establece como el rootViewController de su appDelegate del ventana objeto. Normalmente se hace en el appDelegate del aplicación:didFinishLaunchingWithOptions: método.

    - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
      self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
      //Override point for customization after application launch.
      self.window.rootViewController = [FFDashboardController create];
      [self.window makeKeyAndVisible];
      return YES;
    }

    Como para el uso de UINavigationController como root VC, checkout Vladimir respuesta.

  10. 3

    En respuesta a @Rocotilos, tengo un apéndice que se produjo en mi código que no he visto en otros lugares en los foros. Me encontré en una situación en la que en el comienzo de la aplicación del ciclo de vida, donde la orientación no era conocida en el shouldAutorotate método. Esto provocaba que la aplicación no se mostrará la vista adecuadamente en el paisaje. Después de un par de vueltas en el simulador se estaba trabajando bien.

    Mi escenario es que hay ciertos puntos de vista que obtener apareció en el lugar donde desea el diseño de paisaje. Como tal, no queremos shouldAutorotate para volver en SÍ. Me doy cuenta de que esto podría ser un caso raro para algunos, pero me he pasado un montón de tiempo de diagnóstico de esto y quería pasar a lo largo. Espero que esto sea útil.

    - (BOOL) shouldAutorotate {
    
        BOOL shouldRotate = NO;
        UIInterfaceOrientation orientation = [[UIDevice currentDevice] orientation];
    
        if ([self IsCaseWhereWeDontWantLandscapeAutorotation]) {
            shouldRotate = NO;
        } else if (orientation == UIDeviceOrientationUnknown) {
            //Handle the case where the device's orientation is not yet known
            shouldRotate = YES;
        } else {
            //Handle the normal case
            shouldRotate = (orientation == UIInterfaceOrientationMaskLandscape);
        }
    
        return shouldRotate;
    }
  11. 2

    Resulta que sólo la raíz controles de la vista de estas llamadas. En mi caso esto era normal UINavigationController. Tuve que cambiar esto a una subclase de archivo en el que he añadido los métodos.

    En mi caso yo solo quería que la raíz de la vista de retrato, y el resto vertical + horizontal.

    Appdelegate.h

    - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
    {
        self.window = [[[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]] autorelease];
        //Override point for customization after application launch.
        S2MBookAppRootViewController *masterViewController = [[[S2MBookAppRootViewController alloc] initWithNibName:pref.rootNibName bundle:nil] autorelease];
        self.navigationController = [[[S2MBookAppNavController alloc] initWithRootViewController:masterViewController] autorelease];
    
        self.window.rootViewController = self.navigationController;
    
    
        [self.window makeKeyAndVisible];
        [[UIApplication sharedApplication] setStatusBarStyle:UIStatusBarStyleBlackOpaque animated:YES];
    
        return YES;
    }

    Y la S2MBookAppNavController (subclase de UINavigationController)

    - (BOOL)shouldAutorotate {
        return YES;
    }
    
    - (NSUInteger)supportedInterfaceOrientations
    {
        if([self.viewControllers count] == 1) return UIInterfaceOrientationMaskPortrait;
        return UIInterfaceOrientationMaskPortrait | UIInterfaceOrientationMaskLandscape;
    }

    ACTUALIZACIÓN:
    Cuando se quiere a fuerza de la orientación (al empujar un nuevo punto de vista sobre el nav controlador) probar esta.

    Hacer su UINavigationController también es propio delegado:

    @interface S2MBookAppNavController : UINavigationController <UINavigationControllerDelegate>
    
    @end

    Y en el .m archivo

    - (void)viewDidLoad
    {
        [super viewDidLoad];
        self.delegate = self;
        //Do any additional setup after loading the view.
    }
    
    - (void)navigationController:(UINavigationController *)navigationController didShowViewController:(UIViewController *)viewController animated:(BOOL)animated {
            if ([UIViewController respondsToSelector:@selector(attemptRotationToDeviceOrientation)]) {
                //present/dismiss viewcontroller in order to activate rotating.
                UIViewController *mVC = [[[UIViewController alloc] init] autorelease];
                [self presentModalViewController:mVC animated:NO];
                [self dismissModalViewControllerAnimated:NO];
            }
    }
    • Que fue muy interesante y me señaló en la dirección correcta. El problema de la interfaz me estaba matando, y mi aplicación, incluso me rechazaron. Mi aplicación de la primera versión fue para ios5 – no hay problemas y aprobado en la appstore. La segunda versión que he publicado con cambios muy menores fue rechazada debido a la orientación de los problemas con ios6. ¿Por qué apple tiene que hacer esta mierda! Hasta Votar por ti 🙂
  12. 2

    Sí, el problema es sólo de la ventana.rootViewController método de llamada para devolver la orientación de la máscara.
    Así supportedInterfaceOrientations método debe ser aplicado en viewController que se establece como ventana.rootViewController. Pero en la mayoría de los casos este objeto no es de clase personalizada, por ejemplo, UINavigationController. Una posible solución es la subclase UINavigationController. Pero Apple dice: «Esta clase no es la intención para la creación de subclases», así que prefiero utilizar otro UIViewController para manejar orientaciones y añadió UINavigationController como niño.

    MyRootViewController * myRoot = [MyRootViewController new];
    self.window.rootViewController = myRoot;
    [myRoot addChildViewController:navigationController];
    [myRoot.view addSubview:navigationController.view];

    y en MyRootViewController implementar métodos:

    - (BOOL)shouldAutorotate {
     return YES;
    }
    
    - (NSUInteger)supportedInterfaceOrientations
    {
        //return your mask here e.g.:
        return UIInterfaceOrientationMaskPortrait;
    }
    • supportedInterfaceOrientations se llama para cada controlador de vista en mi aplicación, no sólo la raíz. shouldAutorotate nunca parece conseguir llamado para la raíz del controlador, pero no se llama a veces para otros controladores.
    • supportedInterfaceOrientations() es llamado a todos los de mi UIViewControllers así. No obstante, parece que toma el valor de la raíz ViewController.
  13. 1

    Tengo una serie de vista de los controladores en un UINavigationController, uno de los cuales tenía que ser sólo horizontal. Me fijo por subclases de la UINavigationController y añadiendo el siguiente código:

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

    Esto asegura que el primer controlador de vista dictados de la orientación.

    Hay una advertencia, sin embargo: si usted se mueve de un vc que se limita a paisaje a uno compatible con cualquier orientación, la nueva vista de la pantalla en horizontal, independientemente de la orientación del teléfono.
    Para combatir esto, me coloque el código siguiente en el ilimitado viewControllers:

    - (NSUInteger)supportedInterfaceOrientations{
       if(UIDeviceOrientationIsPortrait([[UIDevice currentDevice] orientation]))       
          return UIInterfaceOrientationMaskPortrait;
       else
          return UIInterfaceOrientationMaskLandscape;
    }
  14. 1
    -(BOOL)shouldAutorotate
    {
        UIDeviceOrientation orientation = [UIDevice currentDevice].orientation;
    
        if (orientation == UIDeviceOrientationUnknown) {
            return YES;
        }
    
        return [self shouldAutorotateToInterfaceOrientation:self.interfaceOrientation];
    }
  15. 1

    Las notas bajo el título UIKit aquí: http://developer.apple.com/library/ios/#releasenotes/General/RN-iOSSDK-6_0/_index.html%23//apple_ref/doc/uid/TP40012166-CH1-SW19 dar algunas pistas para la respuesta, pero no es la imagen completa. No tengo toda la imagen, pero aquí es lo que he encontrado hasta ahora para iOS 6.0 RTM.

    Si usted no está realmente en la restricción de la apoyó orientaciones y, en su lugar, usted está con ganas de hacer algo, porque el usuario girar el dispositivo, entonces usted puede mover la lógica en

    - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation

    a

    - (void)viewWillLayoutSubviews

    lugar.

    Esto probablemente puede ser un reemplazo directo, pero no he probado en el nivel de las versiones de iOS todavía.

    Si desea restringir la apoyó orientaciones, usted debe hacer que en el UIApplicationDelegate nivel con

    -(NSUInteger)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window

    La documentación indica que «El sistema determina si la orientación es apoyado por la intersección entre el valor devuelto por la aplicación del supportedInterfaceOrientationsForWindow: método con el valor devuelto por la supportedInterfaceOrientations método de la parte más completa del controlador de pantalla.» pero en la experimentación he encontrado que el sistema ignora mi punto de vista controladores compatibles

    -(NSUInteger)supportedInterfaceOrientations

    valor de retorno, aunque el método es llamado.

  16. 1

    Apple ha dejado de utilizar shouldautorate método de ios6 uso de estos métodos en su lugar. Consulte a su xcode docs

    - (BOOL)shouldAutorotate NS_AVAILABLE_IOS(6_0);
    - (NSUInteger)supportedInterfaceOrientations NS_AVAILABLE_IOS(6_0);
    //Returns interface orientation masks.
    - (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation NS_AVAILABLE_IOS(6_0);
  17. 0

    Su Trabajo para mí:

    - (BOOL)shouldAutorotate {
        return YES;
    }
    
    - (NSUInteger)supportedInterfaceOrientations {
        NSUInteger orientations = UIInterfaceOrientationMaskPortrait;
        if ([self isKindOfClass:[YourViewController class]]) { //Your view class
            orientations |= UIInterfaceOrientationMaskPortraitUpsideDown;
        }
        return orientations;
    }

    orientaciones:

    orientations |= UIInterfaceOrientationMaskLandscapeLeft;
    orientations |= UIInterfaceOrientationMaskLandscapeRight;

Dejar respuesta

Please enter your comment!
Please enter your name here