Gibt es eine dokumentierte Möglichkeit, die iPhone-Ausrichtung festzulegen?

Ich habe eine App, in der ich die Gerätedrehung in bestimmten Ansichten unterstützen möchte, andere jedoch im Querformat nicht besonders sinnvoll sind. Wenn ich die Ansichten austausche, möchte ich die Drehung auf Hochformat setzen.

Auf UIDevice gibt es einen undokumentierten Eigenschaftssetter, der den Trick ausführt, aber offensichtlich eine Compiler-Warnung generiert und bei einer zukünftigen Überarbeitung des SDK verschwinden könnte.

[[UIDevice currentDevice] setOrientation:UIInterfaceOrientationPortrait];

Gibt es dokumentierte Möglichkeiten, die Orientierung zu erzwingen?

Update: Ich dachte, ich würde ein Beispiel liefern, da ich nicht nach shouldAutorotateToInterfaceOrientation suche, da ich das bereits implementiert habe.

Ich möchte, dass meine App Querformat und Hochformat in Ansicht 1 unterstützt, aber nur Hochformat in Ansicht 2. Ich habe shouldAutorotateToInterfaceOrientation bereits für alle Ansichten implementiert. Wenn sich der Benutzer jedoch in Ansicht 1 im Querformat befindet und dann zu Ansicht 2 wechselt, möchte ich das erzwingen Telefon, um zurück zum Porträt zu drehen.

Dies ist beim späteren iPhone 3.1.2 SDK kein Problem mehr. Es scheint nun die angeforderte Ausrichtung der Ansicht zu berücksichtigen, die auf den Stapel zurückgeschoben wird. Dies bedeutet wahrscheinlich, dass Sie ältere iPhone-Betriebssystemversionen erkennen und setOrientation nur anwenden müssen, wenn es vor der neuesten Version liegt.

Es ist nicht klar, ob die statische Analyse von Apple versteht, dass Sie die älteren SDK-Einschränkungen umgehen. Ich persönlich wurde von Apple angewiesen, den Methodenaufruf bei meinem nächsten Update zu entfernen, sodass ich noch nicht sicher bin, ob ein Hack für ältere Geräte den Genehmigungsprozess durchlaufen wird.

Dies ist lange nachträglich, aber nur für den Fall, dass jemand vorbeikommt, der keinen Navigationscontroller verwendet und / oder keine undokumentierten Methoden verwenden möchte:

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

Es reicht aus, einen Vanilla View Controller zu präsentieren und zu schließen.

Natürlich müssen Sie die Ausrichtung in Ihrer Überschreibung von shouldAutorotateToInterfaceOrientation noch bestätigen oder verweigern. Dies führt jedoch dazu, dass shouldAutorotate ... vom System erneut aufgerufen wird.

Wenn Sie erzwingen möchten, dass es vom Hoch- zum Querformat gedreht wird, finden Sie hier den Code. Beachten Sie nur, dass Sie die Mitte Ihrer Ansicht anpassen müssen. Ich bemerkte, dass meine die Aussicht nicht an der richtigen Stelle platzierte. Ansonsten hat es perfekt funktioniert. Danke für den Tipp.

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

Soweit ich das beurteilen kann, setOrientation:funktioniert die Methode nicht (oder funktioniert möglicherweise nicht mehr). Folgendes mache ich, um dies zu tun:

Fügen Sie diese Definition zuerst oben in Ihre Datei ein, direkt unter Ihren #imports:

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

dann in der viewWillAppear:Methode

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

Wenn Sie möchten, dass das animiert wird, können Sie das Ganze wie folgt in einen Animationsblock einbinden:

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

Anschließend können Sie in Ihrem Hochformat-Modus-Controller den umgekehrten Vorgang ausführen. Überprüfen Sie, ob er sich derzeit im Querformat befindet, und drehen Sie ihn in diesem Fall wieder auf Hochformat.

Ich hatte ein Problem, bei dem ich ein UIViewControllerBild in Querformat auf dem Bildschirm hatte UINavigationController. Wenn der nächste Ansichts-Controller in den Fluss gedrückt wird, musste das Gerät jedoch zur Hochformatausrichtung zurückkehren.

Was mir aufgefallen ist, war, dass die shouldAutorotateToInterfaceOrientation:Methode nicht aufgerufen wird, wenn ein neuer Ansichts-Controller auf den Stapel geschoben wird, sondern aufgerufen wird, wenn ein Ansichts-Controller aus dem Stapel entfernt wird .

Aus diesem Grund verwende ich diesen Codeausschnitt in einer meiner Apps:

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

Grundsätzlich ist es möglich, die Benutzeroberfläche so zu gestalten, dass sie in die Hochformatposition zurückkehrt, indem Sie einen leeren Ansichts-Controller erstellen, ihn auf den Stapel schieben und ihn sofort entfernen. Sobald der Controller geknallt wurde, drücke ich einfach auf den Controller, den ich zuerst drücken wollte. Optisch sieht es gut aus - der leere, beliebige Ansichts-Controller wird vom Benutzer nie gesehen.

Es gibt eine einfache Möglichkeit, das iPhone programmgesteuert in die erforderliche Ausrichtung zu zwingen - unter Verwendung von zwei der bereits bereitgestellten Antworten von 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];

klappt wunderbar :)

BEARBEITEN:

für iOS 6 muss ich folgende Funktion hinzufügen: (funktioniert auf modal viewcontroller)

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

Ich habe gegraben und nach einer guten Lösung dafür gesucht. Wir haben diesen Blog-Beitrag gefunden, der den Trick macht: Entfernen Sie Ihre äußerste Ansicht aus dem Schlüssel UIWindowund fügen Sie sie erneut hinzu. Das System shouldAutorotateToInterfaceOrientation:fragt dann die Methoden von Ihren Ansichtscontrollern erneut ab und erzwingt die korrekte Ausrichtung, die angewendet werden soll. Sehen Sie es: iphone zwingt uiview, sich neu zu orientieren

Joshs Antwort funktioniert gut für mich.

Ich poste jedoch lieber eine Benachrichtigung "Die Ausrichtung hat sich geändert, bitte aktualisieren Sie die Benutzeroberfläche" . Wenn diese Benachrichtigung von einem Ansichts-Controller empfangen wird, ruft er auf shouldAutorotateToInterfaceOrientation:, sodass Sie eine beliebige Ausrichtung festlegen können, indem YESSie zur gewünschten Ausrichtung zurückkehren .

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

Das einzige Problem ist, dass dies eine Neuorientierung ohne Animation erzwingt . Sie müssten diese Linie zwischen beginAnimations:und commitAnimationsumbrechen, um einen reibungslosen Übergang zu erreichen.

Hoffentlich hilft das.

FWIW, hier ist meine Implementierung der manuellen Einstellung der Ausrichtung (um in den Root View Controller Ihrer App zu gelangen, 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 ];     
}

gekoppelt mit der folgenden UINavigationControllerDelegateMethode (vorausgesetzt, Sie verwenden 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 ];
    }
}

Dadurch wird die Stammansicht gedreht, je nachdem, ob ein eingehender UIViewControllerVorgang die aktuelle Geräteorientierung unterstützt. Schließlich möchten Sie sich rotateInterfaceToOrientationmit den tatsächlichen Änderungen der Geräteorientierung verbinden, um die Standard-iOS-Funktionalität nachzuahmen. Fügen Sie diesen Ereignishandler demselben Root-View-Controller hinzu:

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

Registrieren Sie sich schließlich für UIDeviceOrientationDidChangeNotificationBenachrichtigungen in initoder loadviewähnlichem:

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

Das funktioniert bei mir (danke Henry Cooke):

Das Ziel für mich war es, nur Änderungen der Landschaftsorientierung zu behandeln.

Init-Methode:

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

Ich habe eine App, in der ich die Gerätedrehung in bestimmten Ansichten unterstützen möchte, andere jedoch im Querformat nicht besonders sinnvoll sind. Wenn ich die Ansichten austausche, möchte ich die Drehung auf Hochformat setzen.

Mir ist klar, dass der obige ursprüngliche Beitrag in diesem Thread jetzt sehr alt ist, aber ich hatte ein ähnliches Problem damit - dh. Alle Bildschirme in meiner App sind nur Hochformat, mit Ausnahme eines Bildschirms, der vom Benutzer zwischen Querformat und Hochformat gedreht werden kann.

Dies war recht einfach, aber wie bei anderen Posts wollte ich, dass die App unabhängig von der aktuellen Geräteausrichtung automatisch zum Hochformat zurückkehrt, wenn ich zum vorherigen Bildschirm zurückkehre.

Die von mir implementierte Lösung bestand darin, die Navigationsleiste im Querformat auszublenden, sodass der Benutzer nur im Hochformat zu den vorherigen Bildschirmen zurückkehren kann. Daher können alle anderen Bildschirme nur im Hochformat angezeigt werden.

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

Dies hat auch den zusätzlichen Vorteil für meine App, dass im Querformat mehr Bildschirmplatz verfügbar ist. Dies ist nützlich, da auf dem betreffenden Bildschirm PDF-Dateien angezeigt werden.

Hoffe das hilft.

Ich habe das am Ende ziemlich leicht gelöst. Ich habe jeden der oben genannten Vorschläge ausprobiert und bin immer noch zu kurz gekommen. Das war meine Lösung:

Im ViewController, der Querformat bleiben muss (links oder rechts), achte ich auf Orientierungsänderungen:

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

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

    }
}

Beachten Sie alle Super Views / Subviews, die die automatische Größenänderung verwenden, da die view.bounds / frame explizit zurückgesetzt werden ...

Die einzige Einschränkung bei dieser Methode zum Beibehalten der Ansicht "Landschaft" ist die inhärente Animationsumschaltung zwischen Ausrichtungen, die auftreten muss, wenn es besser wäre, wenn sie scheinbar keine Änderung aufweist.

iOS 6-Lösung:

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

Der genaue Code hängt von der App ab und auch davon, wo Sie ihn platzieren (ich habe ihn in meinem AppDelegate verwendet). Ersetzen Sie [[self window] rootViewController]durch das, was Sie verwenden. Ich habe ein UITabBarController.

Ich habe eine Lösung gefunden und etwas auf Französisch geschrieben (aber der Code ist auf Englisch). Hier

Der Weg besteht darin, den Controller zur Fensteransicht hinzuzufügen (der Controller muss über eine gute Implementierung der Funktion shouldRotate .... verfügen).

Wenn Sie UIViewController verwenden, gibt es folgende Methode:

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation

Kehren Sie NOzu den Ansichts-Controllern zurück, die die Ansichten enthalten, die Sie nicht drehen möchten.

Mehr Infos hier

Ich denke nicht, dass dies zur Laufzeit möglich ist, obwohl Sie natürlich einfach eine 90-Grad-Transformation auf Ihre Benutzeroberfläche anwenden könnten.

Das benutze ich. (Sie erhalten einige Kompilierungswarnungen, die jedoch sowohl im Simulator als auch auf dem iPhone funktionieren.)

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