it-swarm.com.de

shouldAutorotateToInterfaceOrientation wird in iOS 6 nicht aufgerufen

Ich verwende MGSplitViewController und shouldAutorotateToInterfaceOrientation, um die Größe des Master-View-Controllers bei Rotation zu steuern. 

Unter iOS 5 funktioniert alles einwandfrei, aber unter iOS 6 (sowohl Simulator als auch iPad) wird shouldAutorotateToInterfaceOrientation nie aufgerufen.

Ist dies ein Fehler, von dem ich erwarten sollte, dass er mit der endgültigen Version von iOS 6 behoben wird?

60

BITTE LESEN SIE SORGFÄLTIG DURCH, oder Sie könnten 1-2 Tage Ihres Lebens verlieren, wenn Sie verrückt werden und kämpfen, schütteln, Ihr Testgerät drehen wie der Schimpanse im Zoo, der das Handy eines Besuchers ergriff! Früher oder später ... Versprechen :)

IN iOS 6

shouldAutorotateToInterfaceOrientation:

ist veraltet und ersetzt durch

shouldAutorotate

es bedeutet, dass iOS 6 niemals shouldAutorotateToInterfaceOrientation aufrufen wird:

wenn Sie also Folgendes in Ihrer Bewerbung verwendet haben

VORiOS6 (iOS5, iOS4 usw.)

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

}

return YES;
}

du solltest benutzen

NACHiOS 6+

- (BOOL)shouldAutorotate {

UIInterfaceOrientation orientation = [[UIApplication sharedApplication] statusBarOrientation];

if (orientation == UIInterfaceOrientationPortrait) {
// your code for portrait mode

}

return YES;
}

SEI VORSICHTIG

UIInterfaceOrientationist eine Eigenschaft von UIApplication und enthält nur 4 Möglichkeiten, die der Ausrichtung der Statusleiste entsprechen:

UIInterfaceOrientationPortrait = UIDeviceOrientationPortrait,

UIInterfaceOrientationPortraitUpsideDown = UIDeviceOrientationPortraitUpsideDown,

UIInterfaceOrientationLandscapeLeft = UIDeviceOrientationLandscapeRight,

UIInterfaceOrientationLandscapeRight = UIDeviceOrientationLandscapeLeft

VERDÜNNEN SIE ES NICHT MIT

UIDeviceOrientationwelches eine Eigenschaft der UIDevice-Klasse ist und 7 mögliche Werte enthält:

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

sie können zwar auchUIDeviceOrientation orientation = [[UIDevice currentDevice] orientation];verwenden, was UIDeviceOrientation - die tatsächliche Ausrichtung des Geräts zurückgibt - ABER Sie müssen wissen, dass UIDeviceOrientation nicht immer gleich UIInterfaceOrientation ist !!! Wenn sich Ihr Gerät beispielsweise in einer reinen Tabelle befindet, können Sie unerwartete Werte erhalten.

Sie können auchUIInterfaceOrientation orientation = self.interfaceOrientation;verwenden, wobei UIInterfaceOrientation die aktuelle Ausrichtung der Schnittstelle zurückgibt, ABER es ist eine Eigenschaft von UIViewController. Sie können also nur in UIViewController-Klassen auf diese zugreifen.

Wenn Sie sowohl ältere iOS6 (iOS3/4/5) - als auch iOS6-Geräte unterstützen möchten - was offensichtlich ist - verwenden Sie einfach shouldAutorotateToInterfaceOrientation: und shouldAutorotate in Ihrem Code.

Ab iOS 6 gibt es 3 Stufen und 3 Schritte, die das Gerät während des App-Starts überprüft, und Sie müssen kontrollieren, ob Sie möchten.

1. Info.plist - Supported Interface Orientations

die Sie grafisch auf der Registerkarte Übersicht festlegen konnten. Die Reihenfolge der zulässigen Ausrichtungen ist WICHTIG. Sie können sie manuell ändern, indem Sie den info.plist bearbeiten. Das Gerät wählt den ersten, wenn die App gestartet wird! Dies ist kritisch, da das Problem immer beim Start der App besteht, wenn die Wahrscheinlichkeit besteht, dass der [UIDevice currentDevice].orientation unbekannt ist, insbesondere wenn wir unsere App auf einer flachen Oberfläche testen.

plist setting in XCode (Info)

BE AWARE Es gibt zwei weitere Einstellungsmöglichkeiten mit der Erweiterung (iPad) oder (iPhone). Wenn Sie eine davon verwenden, wird diese Einstellung des aktuellen Geräts oder Simulators verwendet, und die allgemeinen Einstellungen werden ignoriert Erweiterung. Wenn Sie also nur eine iPhone-App ausführen und aus Versehen eine Zeile "Supported Interface Orientations (iPad)" auch ohne Daten irgendwo in der Liste gespeichert haben, werden die zuvor in den allgemeinen Einstellungen festgelegten Regeln (in meinem Beispiel für iPhone) nicht beachtet ) und Sie könnten eine Ablehnung für Ihre App mit einem Text erhalten "Wir haben festgestellt, dass Ihre App die Voraussetzungen für die Ausführung auf dem iPad nicht erfüllt ...", auch wenn Ihre App nicht beabsichtigt, eine bestimmte Ausrichtung auf dem iPhone, sondern dem iPad zu verwenden wird es verwenden, was zu unvorhergesehenen Fehlern führen kann, da alle iPhone-Apps während des Einreichens auch auf dem iPad laufen müssen.

2. AppDelegate - application:supportedInterfaceOrientationsForWindow

rückgabe einer kleinen Maskenliste aller Ausrichtungen, die Sie zulassen möchten, wodurch die info.plist-Einstellungen überschrieben werden. Dies wird mindestens einmal jedes Mal aufgerufen, wenn sich das Gerät dreht.

3. Top-level view controller or RootViewController - supportedInterfaceOrientations

dies gibt eine Schnittmenge mit der Menge der App und des App-Delegaten vor, die ein Ergebnis ungleich Null haben muss, um einen Absturz zu vermeiden. Dies wird mindestens einmal aufgerufen, wenn sich das Gerät dreht, es sei denn, in unserem Controller ist eine andere Methode installiert:

shouldAutorotate

was die zulässigen Ausrichtungen der App stört und eine BOOL mit dem Standard YES ergibt.

BE CAREFUL when you use `NavigationController`

als oberster Controller in Ihrer AppDelegate wie folgt:

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;

in diesem Fall müssen Sie den folgenden Code in Ihre AppDelegate als Kategorieanbindung an die NavigationController-Klasse einfügen, da dies der oberste Controller ist. Wenn Sie keine Unterkategorie daraus erstellt haben, haben Sie keinen Platz/Code, den Sie festlegen können seine Ausrichtungseinstellungen, also müssen Sie es erzwingen, um Ihre echte rootViewController zu prüfen, in diesem Fall die detailViewController für die Ausrichtungen:

@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

danach können Sie die bevorzugten Ausrichtungen in Ihrer "obersten" ViewController (in meinem Beispiel die detailViewController) mit einer der in iOS 6 verfügbaren Methoden für ViewControllers wie folgt festlegen:

1. (BOOL)shouldAutorotate

2. (NSUInteger)supportedInterfaceOrientations

3. (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation
127
BootMaker

Ok, ich habe es in iOS6 iPad Simulator funktionieren lassen. Yay. Folgendes habe ich getan:

Ich zeige es Ihnen einfach vor und nach, es sollte selbsterklärend sein:

VOR

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {

if (interfaceOrientation==UIInterfaceOrientationPortrait) {
 // do some sh!t

}

return YES;
}

NACH DEM

- (BOOL)shouldAutorotate {

UIInterfaceOrientation orientation = [[UIDevice currentDevice] orientation];

if (orientation==UIInterfaceOrientationPortrait) {
 // do some sh!t

}

return YES;
}

Als unterstützte Ausrichtung können Sie entweder in info.plist als solche angeben: Supported Orientation pic

Oder verwenden Sie den Code:

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

Bearbeiten: Wenn Sie vorhaben, sowohl niedrigere Versionen (iOS4.3/5/5.1) als auch 6.0 zu unterstützen, fügen Sie einfach beide Methoden mit demselben Code-Inhalt hinzu. Funktioniert für mich (in sim sowieso)

55
GeneCode

Das Festlegen des Route-Controllers für das App-Fenster anstatt das Hinzufügen der Ansicht als Unteransicht funktionierte bei mir (wie bei Rocotilos).

//    [self.window addSubview:self.topLevelNavigationController.view];
self.window.rootViewController = self.topLevelNavigationController;
20

Hier ist eine Lösung für iOS 5 und früheren Code, bei der keine Logik kopiert wird. Fügen Sie diesen Code einfach zu Ihrem Ansichtscontroller hinzu, und er generiert die unterstütztenInterfaceOrientations aus Ihrer vorhandenen shouldAutorotateToInterfaceOrientation-Methode.

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

Eine schnelle Lösung für mich bestand darin, diesen Code meinem Root-View-Controller hinzuzufügen

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

Auf diese Weise verwende ich immer noch dieselbe Logik, die für Versionen vor iOS 6 verwendet wurde. Natürlich hatte ich meinen rootViewController ursprünglich in meinen App-Delegaten didFinishLaunchingWithOptions richtig gesetzt, anstatt nur die Windows-Unteransichten hinzuzufügen.

15
g1de0n_ph

Und obwohl in einigen Antworten die Lösung angezeigt wurde - das Implementieren von sollAutorotate und unterstütztInterfaceOrientations für iOS 6-Builds -, sollten Sie sich auch bewusst sein, dass Ihr View Controller in einem Navigationscontroller gehostet wird Runtime ruft diese in der UINavigationController-Instanz auf und ignoriert Ihren Code ansonsten.

Anscheinend besteht die "Lösung" darin, UINavigationController zu subklassen und diese neuen Methoden in dieser Unterklasse wie hier beschrieben zu implementieren: iOS 6 UITabBarController-unterstützte Ausrichtung mit aktuellem UINavigation-Controller

Und dann haben Sie das Vergnügen, Ihren gesamten Code zu ändern, wenn Sie stattdessen einen UINavigationController verwenden, um diese neue Unterklasse zu verwenden.

Dies ist einer der sinnlosesten und ärgerlichsten Änderungen in einer iOS-Version, die ich je gesehen habe.

11

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

Hier ein Zitat aus dem iOS-SDK von Apple, XCode4.5 + (siehe UIViewController-Klassenreferenz, View Rotations behandeln):

In iOS 6 unterstützt Ihre App die in der Info.plist-Datei Ihrer App definierten Schnittstellenausrichtungen. Ein Ansichtscontroller kann die Methode supportedInterfaceOrientations überschreiben, um die Liste der unterstützten Ausrichtungen einzuschränken. Im Allgemeinen Das System ruft diese Methode nur auf dem Root-View-Controller des Fensters oder eines View-Controllers auf, der den gesamten Bildschirm ausfüllt}; Untergeordnete Ansichtscontroller verwenden den Teil des Fensters, der ihnen von ihrem übergeordneten Ansichtscontroller zur Verfügung gestellt wird, und beteiligen sich nicht mehr direkt an der Entscheidung, welche Rotationen unterstützt werden.

Auch in iOS6 ist die shouldAutorotateToInterfaceOrientation: -Methode der UIViewController-Klasse bereits veraltet.

In Ihrem Root-View-Controller erledigen Sie also Folgendes:

- (BOOL)shouldAutorotate {
  return YES;
}

- (NSUInteger)supportedInterfaceOrientations {
  return UIInterfaceOrientationMaskPortrait;
}

Übrigens, "root view controller" ist jede UIViewController-Unterklasse, die Sie als rootViewController des window - Objekts Ihrer appDelegate-Klasse festlegen. Normalerweise machen Sie das in der appDelegate-Methode application: didFinishLaunchingWithOptions:.

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

Um UINavigationController als Root-VCs zu verwenden, checkout Wladimir's Antwort .

3
MkVal

Als Antwort auf @Rocotilos habe ich einen Nachtrag in meinem Code erhalten, den ich an anderer Stelle in den Foren nicht gesehen habe. Ich bin in eine Situation geraten, in der ganz am Anfang des Lebenszyklus der App die Orientierung in der shouldAutorotate-Methode nicht bekannt war. Dies hatte zur Folge, dass die App die Ansicht in der Landschaft nicht richtig anzeigt. Nach ein paar Umdrehungen im Simulator funktionierte es einwandfrei.

Mein Szenario ist, dass es bestimmte Ansichten gibt, bei denen die Landschaftsgestaltung gewünscht wird. Daher möchten wir nicht, dass sollten, wenn Autorotate JA zurückgibt. Ich weiß, dass dies für manche ein seltener Fall sein kann, aber ich habe viel Zeit darauf verwendet, dies zu diagnostizieren und wollte weitergeben. Hoffe das ist hilfreich.

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

Das funktionierte für mich mit iOS6 und Xcode 4.5 GM:

Auf AppDelegate.m

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    .....

    //   self.window.rootViewController = self.navigationController;

    [window setRootViewController:navigationController];

    .....

    return YES;
}

auf ViewController:

- (void)willAnimateRotationToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation duration:(NSTimeInterval)duration

{
    if (UIInterfaceOrientationIsLandscape(interfaceOrientation))

    {
      // landscape
    }
    else
    {
      //portrait
    }
}
3
Carlos Moura

Ja, das Problem ist nur die window.rootViewController-Methode, die aufgerufen wird, um die Orientierungsmaske zurückzugeben .. _. Daher muss die supportedInterfaceOrientations -Methode in viewController implementiert werden, das als window.rootViewController festgelegt ist. In den meisten Fällen ist dieses Objekt jedoch nicht benutzerdefiniert, z. UINavigationController. Eine mögliche Lösung ist die Unterklasse UINavigationController. Apple sagt jedoch: "Diese Klasse ist nicht für Unterklassen gedacht", also habe ich lieber einen anderen UIViewController für Orientierungen verwendet und als Kind UINavigationController hinzugefügt. 

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

und in MyRootViewController implementieren Methoden:

- (BOOL)shouldAutorotate {
 return YES;
}

- (NSUInteger)supportedInterfaceOrientations
{
    // return your mask here e.g.:
    return UIInterfaceOrientationMaskPortrait;
}
2
Vladimir

Es stellt sich heraus, dass nur die Root-Ansicht diese Aufrufe verarbeitet. In meinem Fall war dies ein normaler UINavigationController. Ich musste dies in eine untergeordnete Datei ändern, in der ich die Methoden hinzufügte.

In meinem Fall wollte ich nur das Root-View-Portrait und das Rest-Portrait + Landscape.

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

Und der S2MBookAppNavController (Unterklasse von UINavigationController)

- (BOOL)shouldAutorotate {
    return YES;
}

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

UPDATE: Wenn Sie die Ausrichtung erzwingen möchten (beim Drücken einer neuen Ansicht auf dem Nav-Controller), versuchen Sie dies.

Machen Sie aus Ihrem UINavigationController auch einen eigenen Delegierten:

@interface S2MBookAppNavController : UINavigationController <UINavigationControllerDelegate>

@end

Und in der .m-Datei

- (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];
        }
}
2
ejazz
-(BOOL)shouldAutorotate
{
    UIDeviceOrientation orientation = [UIDevice currentDevice].orientation;

    if (orientation == UIDeviceOrientationUnknown) {
        return YES;
    }

    return [self shouldAutorotateToInterfaceOrientation:self.interfaceOrientation];
}
1
Kumaresan P

Apple hat die von ios6 verwendete Methode als missbraucht empfohlen. Verwenden Sie stattdessen diese Methoden. Sehen Sie Ihre Xcode-Dokumente

- (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);
1
Saad

Ich habe eine Reihe von View-Controllern in einem UINavigationController, von denen einer nur im Querformat sein musste. Ich habe das Problem behoben, indem ich den UINavigationController mit einer Unterklasse versehen und den folgenden Code hinzugefügt habe:

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

Dadurch wird sichergestellt, dass der Controller der obersten Ansicht die Ausrichtung vorgibt.

Es gibt jedoch ein Problem: Wenn Sie sich von einem auf Landschaft beschränkten Vc zu einem Bereich bewegen, der eine beliebige Ausrichtung unterstützt, wird die neue Ansicht unabhängig von der Ausrichtung des Telefons im Querformat angezeigt .. _ Code in den unlimitierten viewControllers:

- (NSUInteger)supportedInterfaceOrientations{
   if(UIDeviceOrientationIsPortrait([[UIDevice currentDevice] orientation]))       
      return UIInterfaceOrientationMaskPortrait;
   else
      return UIInterfaceOrientationMaskLandscape;
}
1
Daz Eddy

Die Anmerkungen unter der Überschrift UIKit finden Sie hier: http://developer.Apple.com/library/ios/#releasenotes/General/RN-iOSSDK-6_0/_index.html%23//Apple_ref/doc/uid/TP40012166- CH1-SW19 gibt ein paar Hinweise auf die Antwort, aber es ist nicht das ganze Bild. Ich habe noch nicht das ganze Bild, aber hier ist das, was ich bisher für iOS 6.0 RTM gefunden habe.

Wenn Sie die unterstützten Ausrichtungen nicht wirklich einschränken und stattdessen etwas tun möchten, weil der Benutzer das Gerät gedreht hat, können Sie die Logik verschieben

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation

zu

- (void)viewWillLayoutSubviews

stattdessen.

Dies kann wahrscheinlich ein direkter Ersatz sein, aber ich habe noch nicht in iOS-Versionen der unteren Ebene getestet.

Wenn Sie die unterstützten Ausrichtungen einschränken möchten, sollten Sie dies auf Ebene UIApplicationDelegate mit tun

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

In der Dokumentation heißt es: "Das System ermittelt, ob eine Ausrichtung unterstützt wird, indem es den von der App supportedInterfaceOrientationsForWindow:-Methode zurückgegebenen Wert mit dem von der unterstütztInterfaceOrientations-Methode des obersten Vollbild-Controllers zurückgegebenen Wert schneidet." Im Experiment habe ich jedoch festgestellt, dass das System meine unterstützten Ansichtscontroller ignoriert

-(NSUInteger)supportedInterfaceOrientations

rückgabewert, auch wenn die Methode aufgerufen wird.

Es arbeitet für mich:

- (BOOL)shouldAutorotate {
    return YES;
}

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

orientierungen:

orientations |= UIInterfaceOrientationMaskLandscapeLeft;
orientations |= UIInterfaceOrientationMaskLandscapeRight;
0
Nazir