¿Existe una forma documentada de configurar la orientación del iPhone?

Tengo una aplicación en la que me gustaría admitir la rotación del dispositivo en ciertas vistas, pero otras no tienen mucho sentido en el modo horizontal, por lo que cuando cambio las vistas, me gustaría forzar la rotación para que se establezca en vertical.

Hay un establecedor de propiedades no documentado en UIDevice que hace el truco, pero obviamente genera una advertencia del compilador y podría desaparecer con una revisión futura del SDK.

[[UIDevice currentDevice] setOrientation:UIInterfaceOrientationPortrait];

¿Existen formas documentadas de forzar la orientación?

Actualización: pensé que proporcionaría un ejemplo ya que no estoy buscando shouldAutorotateToInterfaceOrientation ya que ya lo he implementado.

Quiero que mi aplicación admita el paisaje y el retrato en la Vista 1, pero solo el retrato en la Vista 2. Ya he implementado shouldAutorotateToInterfaceOrientation para todas las vistas, pero si el usuario está en modo horizontal en la Vista 1 y luego cambia a la Vista 2, quiero forzar la teléfono para girar de nuevo a Vertical.

Esto ya no es un problema en la versión posterior del iPhone 3.1.2 SDK. Ahora parece respetar la orientación solicitada de la vista que se devuelve a la pila. Eso probablemente significa que necesitaría detectar versiones anteriores del sistema operativo iPhone y solo aplicar setOrientation cuando sea anterior a la última versión.

No está claro si el análisis estático de Apple comprenderá que está trabajando alrededor de las limitaciones del SDK anterior. Apple me ha dicho personalmente que elimine la llamada al método en mi próxima actualización, por lo que aún no estoy seguro de si tener un truco para dispositivos más antiguos pasará el proceso de aprobación.

Esto es mucho después del hecho, pero en caso de que llegue alguien que no esté usando un controlador de navegación y / o no desee usar métodos no documentados:

UIViewController *c = [[UIViewController alloc]init];
[self presentModalViewController:c animated:NO];
[self dismissModalViewControllerAnimated:NO];
[c release];

Es suficiente presentar y descartar un controlador de vista de vainilla.

Obviamente, aún deberá confirmar o negar la orientación en su anulación de shouldAutorotateToInterfaceOrientation. Pero esto hará que el sistema vuelva a llamar a shouldAutorotate ...

Si desea forzarlo a rotar de retrato a paisaje, aquí está el código. Solo tenga en cuenta que necesita ajustar el centro de su vista. Noté que el mío no colocaba la vista en el lugar correcto. De lo contrario, funcionó perfectamente. Gracias por el consejo.

if(UIInterfaceOrientationIsLandscape(self.interfaceOrientation)){

        [UIView beginAnimations:@"View Flip" context:nil];
        [UIView setAnimationDuration:0.5f];
        [UIView setAnimationCurve:UIViewAnimationCurveEaseInOut];

        self.view.transform = CGAffineTransformIdentity;
        self.view.transform = CGAffineTransformMakeRotation(degreesToRadian(90));
        self.view.bounds = CGRectMake(0.0f, 0.0f, 480.0f, 320.0f);
        self.view.center = CGPointMake(160.0f, 240.0f);

        [UIView commitAnimations];
}

Por lo que puedo decir, el setOrientation:método no funciona (o quizás ya no funciona). Esto es lo que estoy haciendo para hacer esto:

primero, ponga esta definición en la parte superior de su archivo, justo debajo de sus #importaciones:

#define degreesToRadian(x) (M_PI * (x) / 180.0)

luego, en el viewWillAppear:método

[[UIApplication sharedApplication] setStatusBarHidden:YES animated:NO];     
if (self.interfaceOrientation == UIInterfaceOrientationPortrait) {  
    self.view.transform = CGAffineTransformIdentity;
    self.view.transform = CGAffineTransformMakeRotation(degreesToRadian(90));
    self.view.bounds = CGRectMake(0.0, 0.0, 480, 320);
}

si desea que esté animado, puede envolver todo en un bloque de animación, así:

[UIView beginAnimations:@"View Flip" context:nil];
[UIView setAnimationDuration:1.25];
[UIView setAnimationCurve:UIViewAnimationCurveEaseInOut];

[[UIApplication sharedApplication] setStatusBarHidden:YES animated:NO];     
if (self.interfaceOrientation == UIInterfaceOrientationPortrait) {  
    self.view.transform = CGAffineTransformIdentity;
    self.view.transform = CGAffineTransformMakeRotation(degreesToRadian(90));
    self.view.bounds = CGRectMake(0.0, 0.0, 480, 320);
}
[UIView commitAnimations];

Luego, en su controlador de modo vertical, puede hacer lo contrario: verifique si está actualmente en horizontal y, de ser así, gírelo nuevamente a Vertical.

Tenía un problema en el que tenía una UIViewControlleren la pantalla, en una UINavigationController, en orientación horizontal. Sin embargo, cuando el siguiente controlador de vista se introduce en el flujo, necesitaba que el dispositivo volviera a la orientación vertical.

Lo que noté fue que shouldAutorotateToInterfaceOrientation:no se llama al método cuando se inserta un nuevo controlador de vista en la pila, pero se llama cuando se extrae un controlador de vista de la pila .

Aprovechando esto, estoy usando este fragmento de código en una de mis aplicaciones:

- (void)selectHostingAtIndex:(int)hostingIndex {

    self.transitioning = YES;

    UIViewController *garbageController = [[[UIViewController alloc] init] autorelease];
    [self.navigationController pushViewController:garbageController animated:NO];
    [self.navigationController popViewControllerAnimated:NO];

    BBHostingController *hostingController = [[BBHostingController alloc] init];
    hostingController.hosting = [self.hostings objectAtIndex:hostingIndex];
    [self.navigationController pushViewController:hostingController animated:YES];
    [hostingController release];

    self.transitioning = NO;
}

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation {
    if (self.transitioning)
        return (toInterfaceOrientation == UIInterfaceOrientationPortrait);
    else
        return YES;
}

Básicamente, al crear un controlador de vista vacío, empujarlo a la pila y sacarlo inmediatamente, es posible hacer que la interfaz vuelva a la posición vertical. Una vez que se ha abierto el controlador, simplemente presiono el controlador que pretendía presionar en primer lugar. Visualmente, se ve muy bien: el usuario nunca ve el controlador de vista arbitrario y vacío.

Hay una manera simple de forzar programáticamente al iPhone a la orientación necesaria, usando dos de las respuestas ya proporcionadas por kdbdallas , Josh :

//will rotate status bar
[[UIApplication sharedApplication] setStatusBarOrientation:UIInterfaceOrientationLandscapeRight];


//will re-rotate view according to statusbar
UIViewController *c = [[UIViewController alloc]init];
[self presentModalViewController:c animated:NO];
[self dismissModalViewControllerAnimated:NO];
[c release];

Funciona de maravilla :)

EDITAR:

para iOS 6 necesito agregar esta función: (funciona en el controlador de vista modal)

- (NSUInteger)supportedInterfaceOrientations
{
    return (UIInterfaceOrientationMaskLandscapeLeft | UIInterfaceOrientationMaskLandscapeRight);
}

He estado investigando y explorando buscando una buena solución para esto. Encontré esta publicación de blog que hace el truco: elimine su vista más externa de la clave UIWindowy agréguela nuevamente, el sistema volverá a consultar los shouldAutorotateToInterfaceOrientation:métodos de sus controladores de vista, imponiendo la orientación correcta que se aplicará. Véalo : iphone obligando a uiview a reorientarse

La respuesta de Josh funciona bien para mí.

Sin embargo, prefiero publicar una notificación de "la orientación cambió, actualice la interfaz de usuario" . Cuando un controlador de vista recibe esta notificación, llama shouldAutorotateToInterfaceOrientation:, lo que le permite establecer cualquier orientación al regresar YESa la orientación que desee.

[[NSNotificationCenter defaultCenter] postNotificationName:UIDeviceOrientationDidChangeNotification object:nil];

El único problema es que esto obliga a una reorientación sin animación. Debería envolver esta línea entre beginAnimations:y commitAnimationspara lograr una transición suave.

Espero que ayude.

FWIW, aquí está mi implementación de la orientación de configuración manual (para ir en el controlador de vista raíz de su aplicación, natch):

-(void)rotateInterfaceToOrientation:(UIDeviceOrientation)orientation{

    CGRect bounds = [[ UIScreen mainScreen ] bounds ];
    CGAffineTransform t;
    CGFloat r = 0;
    switch ( orientation ) {
        case UIDeviceOrientationLandscapeRight:
            r = -(M_PI / 2);
            break;
        case UIDeviceOrientationLandscapeLeft:
            r  = M_PI / 2;
            break;
    }
    if( r != 0 ){
        CGSize sz = bounds.size;
        bounds.size.width = sz.height;
        bounds.size.height = sz.width;
    }
    t = CGAffineTransformMakeRotation( r );

    UIApplication *application = [ UIApplication sharedApplication ];

    [ UIView beginAnimations:@"InterfaceOrientation" context: nil ];
    [ UIView setAnimationDuration: [ application statusBarOrientationAnimationDuration ] ];
    self.view.transform = t;
    self.view.bounds = bounds;
    [ UIView commitAnimations ];

    [ application setStatusBarOrientation: orientation animated: YES ];     
}

junto con el siguiente UINavigationControllerDelegatemétodo (asumiendo que estás usando a UINavigationController):

-(void)navigationController:(UINavigationController *)navigationController willShowViewController:(UIViewController *)viewController animated:(BOOL)animated{
    // rotate interface, if we need to
    UIDeviceOrientation orientation = [[ UIDevice currentDevice ] orientation ];
    BOOL bViewControllerDoesSupportCurrentOrientation = [ viewController shouldAutorotateToInterfaceOrientation: orientation ];
    if( !bViewControllerDoesSupportCurrentOrientation ){
        [ self rotateInterfaceToOrientation: UIDeviceOrientationPortrait ];
    }
}

Eso se encarga de rotar la vista raíz según si un entrante UIViewControlleradmite la orientación actual del dispositivo. Finalmente, querrás conectarterotateInterfaceToOrientation a los cambios reales de orientación del dispositivo para imitar la funcionalidad estándar de iOS. Agregue este controlador de eventos al mismo controlador de vista raíz:

-(void)onUIDeviceOrientationDidChangeNotification:(NSNotification*)notification{
    UIViewController *tvc = self.rootNavigationController.topViewController;
    UIDeviceOrientation orientation = [[ UIDevice currentDevice ] orientation ];
    // only switch if we need to (seem to get multiple notifications on device)
    if( orientation != [[ UIApplication sharedApplication ] statusBarOrientation ] ){
        if( [ tvc shouldAutorotateToInterfaceOrientation: orientation ] ){
            [ self rotateInterfaceToOrientation: orientation ];
        }
    }
}

Finalmente, regístrese para UIDeviceOrientationDidChangeNotificationrecibir notificaciones en inito me loadviewgusta:

[[ NSNotificationCenter defaultCenter ] addObserver: self
                                           selector: @selector(onUIDeviceOrientationDidChangeNotification:)
                                               name: UIDeviceOrientationDidChangeNotification
                                             object: nil ];
[[ UIDevice currentDevice ] beginGeneratingDeviceOrientationNotifications ];

Esto funciona para mí (gracias Henry Cooke):

El objetivo para mí era tratar únicamente con los cambios de orientación del paisaje.

método init:

[[UIDevice currentDevice] beginGeneratingDeviceOrientationNotifications];
[[NSNotificationCenter defaultCenter] addObserver:self
                                         selector:@selector(orientationChanged:)
                                             name:UIDeviceOrientationDidChangeNotification
                                           object:nil];

- (void)orientationChanged:(NSNotification *)notification {    
    //[[UIDevice currentDevice] endGeneratingDeviceOrientationNotifications];
    UIDeviceOrientation orientation = [UIDevice currentDevice].orientation;
    CGRect bounds = [[ UIScreen mainScreen ] bounds ];
    CGAffineTransform t;
    CGFloat r = 0;
    switch ( orientation ) {
        case UIDeviceOrientationLandscapeRight:
            r = 0;
            NSLog(@"Right");
            break;
        case UIDeviceOrientationLandscapeLeft:
            r  = M_PI;
            NSLog(@"Left");
            break;
        default:return;
    }

    t = CGAffineTransformMakeRotation( r );

    UIApplication *application = [ UIApplication sharedApplication ];
    [ UIView beginAnimations:@"InterfaceOrientation" context: nil ];
    [ UIView setAnimationDuration: [ application statusBarOrientationAnimationDuration ] ];
    self.view.transform = t;
    self.view.bounds = bounds;
    [ UIView commitAnimations ];

    [ application setStatusBarOrientation: orientation animated: YES ];
}

Tengo una aplicación en la que me gustaría admitir la rotación del dispositivo en ciertas vistas, pero otras no tienen mucho sentido en el modo horizontal, por lo que cuando cambio las vistas, me gustaría forzar la rotación para que se establezca en vertical.

Me doy cuenta de que la publicación original anterior en este hilo es muy antigua ahora, pero tuve un problema similar, es decir. todas las pantallas de mi aplicación son solo verticales, con la excepción de una pantalla, que el usuario puede girar entre horizontal y vertical.

Esto fue bastante sencillo, pero al igual que otras publicaciones, quería que la aplicación volviera automáticamente al retrato independientemente de la orientación actual del dispositivo, al regresar a la pantalla anterior.

La solución que implementé fue ocultar la barra de navegación en el modo horizontal, lo que significa que el usuario solo puede volver a las pantallas anteriores mientras está en modo vertical. Por lo tanto, todas las demás pantallas solo pueden estar en modo vertical.

- (void)didRotateFromInterfaceOrientation:(UIInterfaceOrientation)pInterfaceOrientation {
    BOOL lHideNavBar = self.interfaceOrientation == UIInterfaceOrientationPortrait ? NO : YES;
    [self.navigationController setNavigationBarHidden:lHideNavBar animated:YES];
}

Esto también tiene el beneficio adicional para mi aplicación de que hay más espacio de pantalla disponible en modo horizontal. Esto es útil porque la pantalla en cuestión se utiliza para mostrar archivos PDF.

Espero que esto ayude.

Resolví esto con bastante facilidad al final. Probé todas las sugerencias anteriores y aún me quedé corto, así que esta fue mi solución:

En el ViewController que debe permanecer horizontal (izquierda o derecha), escucho los cambios de orientación:

    [[NSNotificationCenter defaultCenter] addObserver:self
                                         selector:@selector(didRotate:)
                                             name:UIDeviceOrientationDidChangeNotification object:nil];

Luego en didRotate:

- (void) didRotate:(NSNotification *)notification
{   if (orientationa == UIDeviceOrientationPortrait) 
    {
        if (hasRotated == NO) 
        {
            NSLog(@"Rotating to portait");
            hasRotated = YES;
            [UIView beginAnimations: @"" context:nil];
            [UIView setAnimationDuration: 0];
            self.view.transform = CGAffineTransformIdentity;
            self.view.transform = CGAffineTransformMakeRotation(DEGREES_TO_RADIANS(-90));
            self.view.bounds = CGRectMake(0.0f, 0.0f, 480.0f, 320.0f);
            self.view.frame = CGRectMake(0.0f, 0.0f, 480.0f, 320.0f);
            [UIView commitAnimations];

    }
}
else if (UIDeviceOrientationIsLandscape( orientationa))
{
    if (hasRotated) 
    {
        NSLog(@"Rotating to lands");
        hasRotated = NO;
        [UIView beginAnimations: @"" context:nil];
        [UIView setAnimationDuration: 0];
        self.view.transform = CGAffineTransformIdentity;
        self.view.transform = CGAffineTransformMakeRotation(DEGREES_TO_RADIANS(0));
        self.view.bounds = CGRectMake(0.0f, 0.0f, 320.0f, 480.0f);
        self.view.frame = CGRectMake(0.0f, 0.0f, 320.0f, 480.0f);
        [UIView commitAnimations];

    }
}

Tenga en cuenta cualquier Supervista / Subvista que use el tamaño automático, ya que view.bounds / frame se está restableciendo explícitamente ...

La única salvedad de este método para mantener la vista horizontal, es el cambio de animación inherente entre las orientaciones que tiene que ocurrir, cuando sería mejor que parezca que no hay cambios.

Solución iOS 6:

[[[self window] rootViewController] presentViewController:[[UIViewController alloc] init] animated:NO completion:^{
    [[[self window] rootViewController] dismissViewControllerAnimated:NO completion:nil];
}];

El código exacto depende de la aplicación y también de dónde lo coloque (lo usé en mi AppDelegate). Reemplace [[self window] rootViewController]con lo que usa. Estaba usando un UITabBarController.

Encontré una solución y escribí algo en francés (pero el código está en inglés). aquí

La forma es agregar el controlador a la vista de la ventana (el controlador debe poseer una buena implementación de la función shouldRotate ....).

Si está utilizando UIViewControllers, existe este método:

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation

Regrese NOpara los controladores de vista que contienen las vistas que no desea rotar.

Más info aquí

No creo que esto sea posible en tiempo de ejecución, aunque, por supuesto, podría aplicar una transformación de 90 grados a su interfaz de usuario.

Esto es lo que utilizo. (Obtiene algunas advertencias de compilación pero funciona tanto en el Simulador como en el iPhone)

[[UIApplication sharedApplication] setStatusBarOrientation:UIInterfaceOrientationLandscapeRight];
[[UIDevice currentDevice] setOrientation:UIInterfaceOrientationLandscapeRight];