iOS 6: come posso limitare alcune visualizzazioni in verticale e consentire ad altre di ruotare?

Ho un'app per iPhone che utilizza a UINavigationControllerper presentare un'interfaccia drill-down: prima una vista, poi un'altra, fino a quattro livelli di profondità. Voglio che le prime tre viste siano limitate all'orientamento verticale e solo l'ultima vista possa ruotare in orizzontale. Quando si torna dalla quarta alla terza vista e la quarta vista era in orientamento orizzontale, voglio che tutto ruoti di nuovo in verticale.

In iOS 5 ho semplicemente definito shouldAutorotateToInterfaceOrientation:in ciascuno dei miei controller di visualizzazione per restituire SÌ per gli orientamenti consentiti. Tutto ha funzionato come descritto sopra, incluso il ritorno alla modalità verticale anche se il dispositivo era tenuto in orientamento orizzontale quando si tornava dal controller di visualizzazione n.

In iOS 6 tutti i controller di visualizzazione ruotano in orizzontale, interrompendo quelli che non erano previsti. Le note di rilascio di iOS 6 dicono

Maggiore responsabilità si sta trasferendo all'app e al delegato dell'app. Ora, i contenitori iOS (come UINavigationController) non consultano i loro figli per determinare se devono ruotare automaticamente. [...] Il sistema richiede al controller di visualizzazione a schermo intero più in alto (in genere il controller di visualizzazione principale) gli orientamenti dell'interfaccia supportati ogni volta che il dispositivo ruota o ogni volta che viene presentato un controller di visualizzazione con lo stile di presentazione modale a schermo intero. Inoltre, gli orientamenti supportati vengono recuperati solo se questo controller di visualizzazione restituisce YES dal suo shouldAutorotatemetodo. [...] Il sistema determina se un orientamento è supportato intersecando il valore restituito dal supportedInterfaceOrientationsForWindow:metodo dell'app con il valore restituito dal supportedInterfaceOrientationsmetodo del controller a schermo intero più in alto.

Quindi ho sottoclasse UINavigationController, ho dato la mia MainNavigationControllerproprietà booleana landscapeOKe l' ho usato per restituire gli orientamenti consentiti in supportedInterfaceOrientations. Quindi in ciascuno dei viewWillAppear:metodi dei controller di visualizzazione ho una riga come questa

    [(MainNavigationController*)[self navigationController] setLandscapeOK:YES];

per dirmi MainNavigationControlleril comportamento desiderato.

Ecco la domanda: se ora passo alla mia quarta vista in modalità verticale e capovolgo il telefono, ruota in orizzontale. Ora premo il pulsante Indietro per tornare alla mia terza visualizzazione che dovrebbe funzionare solo in verticale. Ma non ruota indietro. Come posso farlo fare?

Provai

    [[UIApplication sharedApplication] setStatusBarOrientation:UIInterfaceOrientationPortrait]

nel viewWillAppearmetodo del mio terzo controller di visualizzazione, ma non fa nulla. Questo è il metodo sbagliato da chiamare o forse il posto sbagliato per chiamarlo o dovrei implementare l'intera cosa in un modo completamente diverso?

Ho avuto lo stesso problema e ho trovato una soluzione che funziona per me. Per farlo funzionare, è non è sufficiente ad attuare - (NSUInteger)supportedInterfaceOrientationsnella vostra UINavigationController. È inoltre necessario implementare questo metodo nel controller n. 3, che è il primo ad essere solo verticale dopo lo scatto del controller n. 4. Quindi, ho il seguente codice nel mio UINavigationController:

- (BOOL)shouldAutorotate
{
    return YES;
}

- (NSUInteger)supportedInterfaceOrientations
{
    if (self.isLandscapeOK) {
        // for iPhone, you could also return UIInterfaceOrientationMaskAllButUpsideDown
        return UIInterfaceOrientationMaskAll;
    }
    return UIInterfaceOrientationMaskPortrait;
}

Nel controller di visualizzazione n. 3, aggiungi quanto segue:

- (NSUInteger)supportedInterfaceOrientations
{
    return UIInterfaceOrientationMaskPortrait;
}

Non è necessario aggiungere nulla ai controller di visualizzazione n. 1, n. 2 e n. 4. Questo funziona per me, spero che ti possa aiutare.

Aggiungi un CustomNavigationController

Ignora questi metodi in esso:

-(BOOL)shouldAutorotate
{
    return [[self.viewControllers lastObject] shouldAutorotate];
}

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

- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation
{
    return [[self.viewControllers lastObject] preferredInterfaceOrientationForPresentation];
}

Ora aggiungi tutti gli orientamenti nel plist

Nel controller di visualizzazione aggiungi solo quelli richiesti:

-(BOOL)shouldAutorotate
{
    return YES;
}

-(NSUInteger)supportedInterfaceOrientations
{
    return UIInterfaceOrientationMaskPortrait;
}

questi metodi sovrascrivono i metodi del controller di navigazione

Dopo aver esaminato ogni risposta in innumerevoli domande simili su SO, nessuna delle risposte ha funzionato per me, ma mi hanno dato alcune idee. Ecco come ho risolto il problema:

Innanzitutto, assicurati che gli orientamenti dell'interfaccia supportati nella destinazione del progetto contengano tutti gli orientamenti desiderati per la visualizzazione rotante.

Quindi, crea una categoria di UINavigationController(poiché Apple dice di non sottoclassarla):

@implementation UINavigationController (iOS6AutorotationFix)

-(BOOL)shouldAutorotate {
    return [self.topViewController shouldAutorotate];
}

@end

Importa quella categoria e il controller di visualizzazione che desideri ruotare (che chiamerò RotatingViewController) nel controller di visualizzazione di livello più alto, che dovrebbe contenere il controller di navigazione. In quel controller di visualizzazione, implementare shouldAutorotatecome segue. Tieni presente che questo non dovrebbe essere lo stesso controller di visualizzazione che desideri ruotare.

-(BOOL)shouldAutorotate {

    BOOL shouldRotate = NO;

    if ([navigationController.topViewController isMemberOfClass:[RotatingViewController class]] ) {
        shouldRotate = [navigationController.topViewController shouldAutorotate];
    }

    return shouldRotate;
}

Infine, nel tuo RotatingViewController, implementa shouldAutorotatee supportedInterfaceOrientationscome segue:

-(BOOL)shouldAutorotate {
    // Preparations to rotate view go here
    return YES;
}

-(NSUInteger)supportedInterfaceOrientations {
    return UIInterfaceOrientationMaskAllButUpsideDown; // or however you want to rotate
}

Il motivo per cui è necessario farlo è perché iOS 6 fornisce il controllo della rotazione al controller della vista principale anziché al controller della vista superiore. Se si desidera che la rotazione di una singola vista si comporti in modo diverso rispetto alle altre viste nello stack, è necessario scrivere un caso specifico per essa nel controller della vista principale.

Non ho abbastanza reputazione per commentare la risposta di @ Brian, quindi aggiungerò qui la mia nota.

Brian ha detto che iOS6 fornisce il controllo di rotazione al rootViewController - questo potrebbe non essere solo un UINavigationController come accennato, ma anche un UITabBarController, che era per me. La mia struttura si presenta così:

• UITabBarController
  • UINavigationController
    • UIViewControllers ...
  • UINavigationController
    • UIViewControllers ...

Quindi ho aggiunto i metodi prima in un UITabBarController personalizzato, poi in un UINavigationController personalizzato e infine nello specifico UIViewController.

Esempio da UITabBarController e UINavigationController:

- (BOOL)shouldAutorotate {
    return [self.viewControllers.lastObject shouldAutorotate];
}

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation {
    return [self.viewControllers.lastObject shouldAutorotateToInterfaceOrientation:toInterfaceOrientation];
}

- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation {
    return [self.viewControllers.lastObject preferredInterfaceOrientationForPresentation];
}

Vorrei dare una risposta parziale alla mia domanda. Ho trovato la seguente riga di codice, utilizzata nel viewWillAppearmetodo del mio terzo UIViewController, per funzionare:

[[UIDevice currentDevice] 
      performSelector:NSSelectorFromString(@"setOrientation:") 
           withObject:(id)UIInterfaceOrientationPortrait];

Ma non mi piace molto questa soluzione. Sta usando un trucco per assegnare a una proprietà di sola lettura che secondo la documentazione Apple rappresenta l' orientamento fisico del dispositivo. È come dire all'iPhone di saltare all'orientamento corretto nella mano dell'utente.

Sono molto tentato di lasciarlo nella mia app poiché funziona semplicemente. Ma non mi sembra giusto, quindi vorrei lasciare la domanda aperta per una soluzione pulita.

Questo è quello che sto usando per il supporto dell'orientamento in ios 6.0

-(BOOL)shouldAutorotate{
    return YES;
}  

 - (NSUInteger)supportedInterfaceOrientations{
    return UIInterfaceOrientationMaskAll;
}


- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation{  
  return UIInterfaceOrientationPortrait;
}

Essendo che questo è un thread molto visto. Ho pensato di aggiungere quella che credo sia la risposta più semplice. Funziona per ios8 e versioni successive

-(BOOL)shouldAutorotate
{
    return YES;
}

e

-(UIInterfaceOrientationMask)supportedInterfaceOrientations{
return UIInterfaceOrientationMaskPortrait;
}

Questo è tutto. Godere!

Oh, ei miei ViewController sono incorporati in un controller di navigazione, che non avevo bisogno di sottoclassare o configurare in alcun modo.

Questo potrebbe non funzionare per tutti, ma funziona benissimo per me. Invece di implementare ...

[(MainNavigationController*)[self navigationController] setLandscapeOK:YES];

in viewWillAppear in tutti i miei controller, ho deciso di centralizzare questo processo all'interno della mia sottoclasse UINavigationController sovrascrivendo il metodo UINavigationControllerDelegatenavigationController:willShowViewController:animated:

- (void)navigationController:(UINavigationController *)navigationController willShowViewController:(UIViewController *)viewController animated:(BOOL)animated {

    self.previousVCLandscapeOK = self.isLandscapeOK; // Store the current VC's orientation preference before pushing on the new VC so we can set this again from within the custom "back" method
    self.isLandscapeOK = NO; // Set NO as default for all VC's
    if ([viewController isKindOfClass:[YourViewController class]]) {
        self.isLandscapeOK = YES;
    }
}

Ho scoperto che questo metodo delegato non viene chiamato quando si estrae un VC dallo stack di navigazione. Questo non è stato un problema per me perché sto gestendo la funzionalità posteriore dalla mia sottoclasse UINavigationController in modo da poter impostare i pulsanti e le azioni della barra di navigazione corretti per VC specifici come questo ...

if ([viewController isKindOfClass:[ShareViewController class]]) {

    UIButton* backButton = [[UIButton alloc] initWithFrame:CGRectMake(0, 0, 57, 30)];
    [backButton setImage:[UIImage imageNamed:@"back-arrow"] forState:UIControlStateNormal];
    [backButton addTarget:self action:@selector(back) forControlEvents:UIControlEventTouchUpInside];
    UIBarButtonItem* backButtonItem = [[UIBarButtonItem alloc] initWithCustomView:backButton];
    viewController.navigationItem.leftBarButtonItem = backButtonItem;

    UIImageView* shareTitle = [[UIImageView alloc] initWithImage:[UIImage imageNamed:@"share-title"]];
    [shareTitle setContentMode:UIViewContentModeScaleAspectFit];
    [shareTitle setFrame:CGRectMake(0, 0, shareTitle.frame.size.width - 10, shareTitle.frame.size.height - 10)];
    viewController.navigationItem.titleView = shareTitle;

} else if(...) {
    ...
}

Ecco backcome appare il mio metodo per gestire la rimozione del VC dallo stack e per impostare la preferenza di rotazione appropriata ...

- (void)back {
    self.isLandscapeOK = self.previousVCLandscapeOK;
    self.previousVCLandscapeOK = NO;
    [self popViewControllerAnimated:YES];
}

Quindi, come puoi vedere, in pratica tutto ciò che sta accadendo è che per prima cosa mi sto impostando due proprietà ...

@property (nonatomic) BOOL isLandscapeOK;
@property (nonatomic) BOOL previousVCLandscapeOK;

in navigationController:willShowViewController:animated:cui determinerà quali sono gli orientamenti supportati all'interno di quel VC che sta per essere presentato. Quando si apre un VC, viene chiamato il mio metodo "back" personalizzato e quindi si imposta isLandscapeOK su ciò che è stato memorizzato tramite il valore previousVCLandscapeOK.

Come ho detto, questo potrebbe non funzionare per tutti, ma funziona benissimo per me e non devo preoccuparmi di aggiungere codice a ciascuno dei miei controller di visualizzazione, sono stato in grado di mantenere tutto centralizzato nella sottoclasse UINavigationController.

Spero che questo aiuti qualcuno come ha fatto con me. Grazie, Jeremy.

Vai al tuo file Info.plist e apporta la modifica

Vuoi forzare il ritratto dell'app iOS 6 solo dopo puoi aggiungere a una sottoclasse UIViewController sotto i metodi

- (BOOL)shouldAutorotate {
    if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
        return YES;
    } else {
        return NO;
    }
}


- (NSUInteger)supportedInterfaceOrientations {
    if (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad) {
        return UIInterfaceOrientationMaskAll;
    } else {
        return UIInterfaceOrientationMaskPortrait;
    }
}

Volevo che tutti i miei VC fossero bloccati sull'orientamento verticale tranne uno. Questo è ciò che ha funzionato per me.

1. Aggiungi il supporto per tutti gli orientamenti nel file plist.

2. Nel controller di visualizzazione radice, rileva il tipo di controller di visualizzazione che si trova nella parte superiore della finestra e imposta l'orientamento dell'app di conseguenza nel metodo supportedInterfaceOrientations . Ad esempio, avevo bisogno che la mia app ruotasse solo quando la visualizzazione web era in cima allo stack. Ecco cosa ho aggiunto nel mio rootVC:

   -(NSUInteger)supportedInterfaceOrientations
   {
       UIViewController *topMostViewController = [[Utils getAppDelegate] appNavigationController].topViewController;
       if ([topMostViewController isKindOfClass:[SVWebViewController class]]) {
           return UIInterfaceOrientationMaskAllButUpsideDown;
       }
       return UIInterfaceOrientationMaskPortrait;
   }

Non ho abbastanza reputazione per rispondere alla domanda di @Ram S sotto la risposta di @micmdk, quindi aggiungerò la mia nota qui.

Quando usi UITabbarController , prova a cambiare self.viewControllers.lastObject nel codice di @ micmdk in self.selectedViewController in questo modo:

- (BOOL)shouldAutorotate {
    return [self.selectedViewController shouldAutorotate];
}

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

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation {
    return [self.selectedViewController shouldAutorotateToInterfaceOrientation:toInterfaceOrientation];
}

- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation {
    return [self.selectedViewController preferredInterfaceOrientationForPresentation];
}

Puoi implementare e sovrascrivere shouldAutorotate () e supportedInterfaceOrientations var in tutte le classi del controller di visualizzazione che dovrebbero essere presentate con orientamenti diversi rispetto a quelli definiti in PLIST della tua app.

Tuttavia, in un'interfaccia utente non banale potresti incontrare un problema per aggiungerla in dozzine di classi e non vuoi renderle tutte sottoclassi di diversi comuni che la supportano (MyBaseTableViewController, MyBaseNavigationController e MyBaseTabBarController).

Poiché non è possibile sovrascrivere direttamente quei metodi / var su UIViewController, è possibile farlo nelle sue sottoclassi che sono in genere classi di base come UITableViewController, UINavigationController e UITabBarController.

Quindi puoi implementare alcune estensioni e configurare comunque MyPreciousViewController in modo che venga visualizzato con orientamenti diversi rispetto a tutti gli altri come questo frammento di codice Swift 4:

extension UITableViewController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {

    if let last = self.navigationController?.childViewControllers.last,
        last != self {
            return last.supportedInterfaceOrientations
    } else {
        return [.portrait]
    }
    }
}

extension MyPreciousViewController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {

    return [.portrait,.landscape]
    }
}


extension UINavigationController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {

        return [.portrait]
    }
}


extension UITabBarController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {

        return [.portrait]
    }
}

Ho risolto lo stesso tipo di problema.

Se stai usando il UINavigationControllerper spingere i controller di visualizzazione, devi impostare i metodi seguenti.

extension UINavigationController{

    override open var shouldAutorotate: Bool {

        if topViewController != nil && (topViewController?.isKind(of: LogInViewController.self))!
        {
            return true
        }
        return false
    }

    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {

        if topViewController != nil && (topViewController?.isKind(of: LogInViewController.self))!
        {
            return .portrait
        }
        return .landscapeRight

    }
    override open var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {

        if topViewController != nil && (topViewController?.isKind(of: LogInViewController.self))!
        {
            return .portrait
        }
        return .landscapeRight
    }
}

Al posto LoginViewControllerdell'uso che UIViewControllervuoi mostrare. Nel mio caso, voglio mostrare LoginViewControllernella Portraitmodalità altro ViewControllersin landscapemodalità.

Si prega di utilizzare il seguente metodo per risolvere questo problema

- (NSUInteger)supportedInterfaceOrientations
{
    return UIInterfaceOrientationMaskPortrait;
}

restituisci solo l'orientamento che desideri !!!