Esiste un modo documentato per impostare l'orientamento dell'iPhone?

Ho un'app in cui vorrei supportare la rotazione del dispositivo in determinate visualizzazioni, ma altre non hanno particolarmente senso in modalità Landscape, quindi mentre cambio le visualizzazioni vorrei forzare la rotazione in verticale.

C'è un setter di proprietà non documentato su UIDevice che fa il trucco ma ovviamente genera un avviso del compilatore e potrebbe scomparire con una futura revisione dell'SDK.

[[UIDevice currentDevice] setOrientation:UIInterfaceOrientationPortrait];

Esistono modi documentati per forzare l'orientamento?

Aggiornamento: ho pensato di fornire un esempio in quanto non sto cercando shouldAutorotateToInterfaceOrientation poiché l'ho già implementato.

Voglio che la mia app supporti il ​​paesaggio e il ritratto nella Vista 1 ma solo il ritratto nella Vista 2. Ho già implementato shouldAutorotateToInterfaceOrientation per tutte le viste ma se l'utente è in modalità orizzontale nella Vista 1 e poi passa alla Vista 2, voglio forzare il telefono per ruotare di nuovo in verticale.

Questo non è più un problema sul successivo iPhone 3.1.2 SDK. Ora sembra onorare l'orientamento richiesto della vista che viene reinserita nella pila. Ciò probabilmente significa che dovresti rilevare le versioni precedenti di iPhone OS e applicare il setOrientation solo quando è precedente all'ultima versione.

Non è chiaro se l'analisi statica di Apple capirà che stai aggirando le limitazioni dell'SDK meno recenti. Personalmente mi è stato detto da Apple di rimuovere la chiamata al metodo al mio prossimo aggiornamento, quindi non sono ancora sicuro se un hack per dispositivi più vecchi supererà il processo di approvazione.

Questo è molto tempo dopo il fatto, ma nel caso in cui qualcuno si presenti che non utilizza un controller di navigazione e / o non desidera utilizzare metodi non documentati:

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

È sufficiente presentare e chiudere un controller di visualizzazione vanilla.

Ovviamente dovrai comunque confermare o negare l'orientamento nel tuo override di shouldAutorotateToInterfaceOrientation. Ma questo farà sì che shouldAutorotate ... venga nuovamente chiamato dal sistema.

Se vuoi forzare la rotazione da verticale a orizzontale, ecco il codice. Tieni presente che devi regolare il centro della tua vista. Ho notato che la mia non posizionava la vista nel posto giusto. Altrimenti, ha funzionato perfettamente. Grazie per il consiglio.

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

Da quello che posso dire, il file setOrientation: metodo non funziona (o forse non funziona più). Ecco cosa sto facendo per farlo:

per prima cosa, metti questa definizione all'inizio del tuo file, proprio sotto le tue #import:

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

poi, nel viewWillAppear:metodo

[[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);
}

se vuoi che sia animato, puoi avvolgere il tutto in un blocco di animazione, in questo modo:

[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];

Quindi, nel controller della modalità verticale, puoi fare il contrario: controlla se è attualmente in orizzontale e, in tal caso, ruotalo di nuovo su Verticale.

Stavo riscontrando un problema a causa del quale UIViewControllersullo schermo era visualizzato un UINavigationController, in orientamento orizzontale. Quando il controller di visualizzazione successivo viene inserito nel flusso, tuttavia, avevo bisogno che il dispositivo tornasse all'orientamento verticale.

Quello che ho notato è che il shouldAutorotateToInterfaceOrientation:metodo non viene chiamato quando un nuovo controller di visualizzazione viene inserito nello stack, ma viene chiamato quando un controller di visualizzazione viene estratto dallo stack .

Approfittando di questo, sto usando questo frammento di codice in una delle mie app:

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

Fondamentalmente, creando un controller di visualizzazione vuoto, inserendolo nello stack e rimuovendolo immediatamente, è possibile riportare l'interfaccia in posizione verticale. Una volta che il controller è stato aperto, spingo semplicemente il controller che intendevo spingere in primo luogo. Visivamente, sembra fantastico: il controller di visualizzazione vuoto e arbitrario non viene mai visto dall'utente.

C'è un modo semplice per forzare programmaticamente l'iPhone all'orientamento necessario, utilizzando due delle risposte già fornite da 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];

funziona come un incantesimo :)

MODIFICARE:

per iOS 6 devo aggiungere questa funzione: (funziona su viewcontroller modale)

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

Ho scavato e scavato cercando una buona soluzione a questo. Ho trovato questo post del blog che fa il trucco: rimuovi la tua vista più esterna dalla chiave UIWindowe aggiungila di nuovo, il sistema interrogherà nuovamente i shouldAutorotateToInterfaceOrientation:metodi dai tuoi viewcontroller, imponendo l'orientamento corretto da applicare. Guardalo : iphone costringe uiview a riorientarsi

La risposta di Josh funziona bene per me.

Tuttavia, preferisco pubblicare una notifica "l'orientamento è cambiato, aggiorna l'interfaccia utente" . Quando questa notifica viene ricevuta da un controller di visualizzazione, chiama shouldAutorotateToInterfaceOrientation:, consentendo di impostare qualsiasi orientamento tornando YESper l'orientamento desiderato.

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

L'unico problema è che questo forza un riorientamento senza un'animazione. Avresti bisogno di racchiudere questa linea tra beginAnimations:ecommitAnimations per ottenere una transizione graduale.

Spero che aiuti.

FWIW, ecco la mia implementazione dell'impostazione manuale dell'orientamento (per andare nel controller di visualizzazione principale della tua app, 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 ];     
}

accoppiato con il seguente UINavigationControllerDelegatemetodo (supponendo che tu stia 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 ];
    }
}

Ciò si occupa di ruotare la vista root a seconda che un ingresso UIViewControllersupporti l'orientamento del dispositivo corrente. Infine, ti consigliamo di collegarti rotateInterfaceToOrientationalle effettive modifiche dell'orientamento del dispositivo per imitare la funzionalità iOS standard. Aggiungi questo gestore eventi allo stesso controller di visualizzazione radice:

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

Infine, registrati per le UIDeviceOrientationDidChangeNotificationnotifiche in inito in questo loadviewmodo:

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

Questo funziona per me (grazie Henry Cooke):

Lo scopo per me era affrontare solo i cambiamenti di orientamento del paesaggio.

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

Ho un'app in cui vorrei supportare la rotazione del dispositivo in determinate visualizzazioni, ma altre non hanno particolarmente senso in modalità Landscape, quindi mentre cambio le visualizzazioni vorrei forzare la rotazione in verticale.

Mi rendo conto che il post originale di cui sopra in questo thread è molto vecchio ora, ma ho avuto un problema simile ad esso - ad es. tutti gli schermi nella mia App sono solo verticali, ad eccezione di uno schermo, che può essere ruotato tra orizzontale e verticale dall'utente.

Questo è stato abbastanza semplice, ma come altri post, volevo che l'app tornasse automaticamente in verticale indipendentemente dall'orientamento del dispositivo corrente, quando si torna alla schermata precedente.

La soluzione che ho implementato è stata quella di nascondere la barra di navigazione in modalità orizzontale, il che significa che l'utente può tornare alle schermate precedenti solo in verticale. Pertanto, tutti gli altri schermi possono essere solo in verticale.

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

Questo ha anche il vantaggio aggiuntivo per la mia app in quanto c'è più spazio sullo schermo disponibile in modalità orizzontale. Ciò è utile perché la schermata in questione viene utilizzata per visualizzare i file PDF.

Spero che questo ti aiuti.

Alla fine l'ho risolto abbastanza facilmente. Ho provato tutti i suggerimenti di cui sopra e sono ancora venuto a mancare, quindi questa era la mia soluzione:

Nel ViewController che deve rimanere orizzontale (sinistro o destro), ascolto i cambiamenti di orientamento:

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

Quindi in 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];

    }
}

Tieni presente qualsiasi Super Visualizzazioni / Sottoviste che utilizzano il ridimensionamento automatico, poiché view.bounds / frame vengono reimpostati esplicitamente ...

L'unico avvertimento a questo metodo per mantenere la vista Paesaggio, è l'animazione intrinseca che passa da un orientamento all'altro che deve verificarsi, quando sarebbe meglio che sembri non avere cambiamenti.

Soluzione iOS 6:

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

Il codice esatto dipende dall'app e anche da dove lo posizioni (l'ho usato nel mio AppDelegate). Sostituisci [[self window] rootViewController]con quello che usi. Stavo usando un file UITabBarController.

Ho trovato una soluzione e ho scritto qualcosa in francese (ma il codice è in inglese). Qui

Il modo è aggiungere il controller alla visualizzazione della finestra (il controller deve possedere una buona implementazione della funzione shouldRotate ....).

Se stai usando UIViewControllers, c'è questo metodo:

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation

Torna NOper i controller di visualizzazione che contengono le visualizzazioni che non desideri ruotare.

Maggiori info qui

Non penso che questo sia possibile in fase di esecuzione, anche se ovviamente potresti semplicemente applicare una trasformazione di 90 gradi alla tua interfaccia utente.

Questo è quello che uso. (Ricevi alcuni avvisi di compilazione ma funziona sia nel simulatore che nell'iPhone)

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