Existe-t-il un moyen documenté de définir l'orientation de l'iPhone?

J'ai une application dans laquelle je voudrais prendre en charge la rotation de l'appareil dans certaines vues, mais d'autres n'ont pas particulièrement de sens en mode Paysage, donc lorsque j'échange les vues, je voudrais forcer la rotation à être définie sur portrait.

Il y a un setter de propriété non documenté sur UIDevice qui fait l'affaire mais génère évidemment un avertissement du compilateur et pourrait disparaître avec une future révision du SDK.

[[UIDevice currentDevice] setOrientation:UIInterfaceOrientationPortrait];

Existe-t-il des moyens documentés pour forcer l'orientation?

Mise à jour: J'ai pensé que je fournirais un exemple car je ne recherche pas shouldAutorotateToInterfaceOrientation car je l'ai déjà implémenté.

Je veux que mon application prenne en charge le paysage et le portrait dans la vue 1, mais uniquement le portrait dans la vue 2. J'ai déjà implémenté shouldAutorotateToInterfaceOrientation pour toutes les vues, mais si l'utilisateur est en mode paysage dans la vue 1 et passe ensuite à la vue 2, je veux forcer la téléphone pour revenir à Portrait.

Ce n'est plus un problème sur le dernier SDK iPhone 3.1.2. Il semble maintenant respecter l'orientation demandée de la vue repoussée sur la pile. Cela signifie probablement que vous devrez détecter les anciennes versions de l'iPhone OS et n'appliquer setOrientation que lorsqu'il est antérieur à la dernière version.

Il n'est pas clair si l'analyse statique d'Apple comprendra que vous contournez les anciennes limitations du SDK. Personnellement, Apple m'a demandé de supprimer l'appel de méthode lors de ma prochaine mise à jour, je ne suis donc pas encore sûr que le piratage d'appareils plus anciens passera par le processus d'approbation.

C'est longtemps après les faits, mais juste au cas où quelqu'un viendrait sans utiliser de contrôleur de navigation et / ou ne souhaitant pas utiliser de méthodes non documentées:

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

Il suffit de présenter et de rejeter un contrôleur de vue vanille.

De toute évidence, vous devrez toujours confirmer ou refuser l'orientation dans votre remplacement de shouldAutorotateToInterfaceOrientation. Mais cela entraînera le rappel de shouldAutorotate ... par le système.

Si vous voulez le forcer à pivoter de portrait en paysage, voici le code. Notez simplement que vous devez ajuster le centre de votre vue. J'ai remarqué que la mienne ne plaçait pas la vue au bon endroit. Sinon, cela fonctionnait parfaitement. Merci pour le conseil.

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

D'après ce que je peux dire, la setOrientation:méthode ne fonctionne pas (ou peut-être ne fonctionne plus). Voici ce que je fais pour faire ceci:

tout d'abord, placez cette définition en haut de votre fichier, juste sous vos #imports:

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

puis, dans la viewWillAppear:méthode

[[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 vous voulez que cela soit animé, vous pouvez envelopper le tout dans un bloc d'animation, comme ceci:

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

Ensuite, dans votre contrôleur de mode portrait, vous pouvez faire l'inverse - vérifiez s'il est actuellement en mode paysage, et si c'est le cas, faites-le pivoter vers Portrait.

J'avais un problème où j'avais un UIViewControllerà l'écran, dans un UINavigationController, en orientation paysage. Cependant, lorsque le contrôleur de vue suivant est poussé dans le flux, j'avais besoin que l'appareil revienne en orientation portrait.

Ce que j'ai remarqué, c'est que la shouldAutorotateToInterfaceOrientation:méthode n'est pas appelée lorsqu'un nouveau contrôleur de vue est poussé sur la pile, mais qu'elle est appelée lorsqu'un contrôleur de vue est sorti de la pile .

Profitant de cela, j'utilise cet extrait de code dans l'une de mes applications:

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

Fondamentalement, en créant un contrôleur de vue vide, en le poussant sur la pile et en le faisant sauter immédiatement, il est possible que l'interface revienne à la position portrait. Une fois que le contrôleur a été sauté, j'appuie simplement sur le contrôleur que j'avais l'intention de pousser en premier lieu. Visuellement, cela a fière allure - le contrôleur de vue vide et arbitraire n'est jamais vu par l'utilisateur.

Il existe un moyen simple de forcer par programmation l'iPhone à l'orientation nécessaire - en utilisant deux des réponses déjà fournies par 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];

fonctionne comme un charme :)

ÉDITER:

pour iOS 6, je dois ajouter cette fonction: (fonctionne sur modal viewcontroller)

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

J'ai creusé et creusé à la recherche d'une bonne solution à cela. J'ai trouvé ce billet de blog qui fait l'affaire: supprimez votre vue la plus externe de la clé UIWindowet ajoutez-la à nouveau, le système interrogera ensuite à nouveau les shouldAutorotateToInterfaceOrientation:méthodes de vos contrôleurs de vue, en imposant l'orientation correcte à appliquer. Voir: iPhone forçant uiview à se réorienter

La réponse de Josh fonctionne bien pour moi.

Cependant, je préfère publier une notification "L'orientation a changé, veuillez mettre à jour l'interface utilisateur" . Lorsque cette notification est reçue par un contrôleur de vue, il appelle shouldAutorotateToInterfaceOrientation:, vous permettant de définir n'importe quelle orientation en retournant YESpour l'orientation souhaitée.

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

Le seul problème est que cela force une réorientation sans animation. Vous devrez envelopper cette ligne entre beginAnimations:et commitAnimationspour obtenir une transition en douceur.

J'espère que cela pourra aider.

FWIW, voici mon implémentation de la définition manuelle de l'orientation (pour aller dans le contrôleur de vue racine de votre application, 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 ];     
}

couplé à la UINavigationControllerDelegateméthode suivante (en supposant que vous utilisez 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 ];
    }
}

Cela prend en charge la rotation de la vue racine selon que l'entrée UIViewControllerprend en charge l'orientation actuelle de l'appareil. Enfin, vous voudrez vous connecter rotateInterfaceToOrientationaux changements d'orientation réels de l'appareil afin d'imiter les fonctionnalités iOS standard. Ajoutez ce gestionnaire d'événements au même contrôleur de vue racine:

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

Enfin, inscrivez-vous aux UIDeviceOrientationDidChangeNotificationnotifications dans initou loadviewcomme suit:

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

Cela fonctionne pour moi (merci Henry Cooke):

Le but pour moi était de traiter uniquement des changements d'orientation du paysage.

méthode 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 ];
}

J'ai une application dans laquelle je voudrais prendre en charge la rotation de l'appareil dans certaines vues, mais d'autres n'ont pas particulièrement de sens en mode Paysage, donc lorsque j'échange les vues, je voudrais forcer la rotation à être définie sur portrait.

Je me rends compte que le message original ci-dessus dans ce fil est très ancien maintenant, mais j'ai eu un problème similaire - à savoir. tous les écrans de mon application sont uniquement en mode portrait, à l'exception d'un écran, qui peut être pivoté entre paysage et portrait par l'utilisateur.

C'était assez simple, mais comme d'autres articles, je voulais que l'application revienne automatiquement en portrait quelle que soit l'orientation actuelle de l'appareil, lors du retour à l'écran précédent.

La solution que j'ai mise en œuvre était de masquer la barre de navigation en mode paysage, ce qui signifie que l'utilisateur ne peut revenir aux écrans précédents qu'en mode portrait. Par conséquent, tous les autres écrans ne peuvent être qu'en mode portrait.

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

Cela présente également l'avantage supplémentaire pour mon application en ce sens qu'il y a plus d'espace d'écran disponible en mode paysage. Ceci est utile car l'écran en question est utilisé pour afficher des fichiers PDF.

J'espère que cela t'aides.

J'ai résolu cela assez facilement à la fin. J'ai essayé toutes les suggestions ci-dessus et j'ai toujours échoué, alors c'était ma solution:

Dans le ViewController qui doit rester Paysage (Gauche ou Droite), j'écoute les changements d'orientation:

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

Puis dans 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];

    }
}

Gardez à l'esprit toutes les super vues / sous-vues qui utilisent le redimensionnement automatique, car les vues.bonds / cadre sont réinitialisés explicitement ...

La seule mise en garde à cette méthode pour conserver la vue Paysage, est l'animation inhérente à la commutation entre les orientations qui doit se produire, alors qu'il serait préférable qu'elle semble n'avoir aucun changement.

Solution iOS 6:

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

Le code exact dépend de l'application et de l'endroit où vous le placez (je l'ai utilisé dans mon AppDelegate). Remplacez [[self window] rootViewController]par ce que vous utilisez. J'utilisais un fichier UITabBarController.

J'ai trouvé une solution et j'ai écrit quelque chose en français (mais le code est en anglais). ici

Le moyen est d'ajouter le contrôleur à la vue de la fenêtre (le contrôleur doit posséder une bonne implémentation de la fonction shouldRotate ....).

Si vous utilisez UIViewControllers, il existe cette méthode:

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation

Retournez NOpour les contrôleurs de vue contenant les vues que vous ne souhaitez pas faire pivoter.

Plus d'infos ici

Je ne pense pas que cela soit possible au moment de l'exécution, bien que vous puissiez bien sûr simplement appliquer une transformation à 90 degrés à votre interface utilisateur.

C'est ce que j'utilise. (Vous obtenez des avertissements de compilation mais cela fonctionne à la fois dans le simulateur et l'iPhone)

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