Come bloccare l'orientamento di un controller di visualizzazione in modalità verticale solo in Swift

Question 1

Dal momento che la mia app ha il supporto per tutti gli orientamenti. Vorrei bloccare solo la modalità verticale su UIViewController specifico.

ad esempio, supponiamo che fosse un'applicazione a schede e quando la visualizzazione di accesso appare in modo modale, voglio solo che la visualizzazione di accesso sia solo in modalità verticale, indipendentemente da come l'utente ruota il dispositivo o come sarà l'orientamento del dispositivo corrente

Question 2

Le cose possono diventare piuttosto complicate quando si ha una gerarchia di visualizzazioni complicata, come avere più controller di navigazione e / o controller di visualizzazione a schede.

Questa implementazione lo inserisce nei singoli controller di visualizzazione per impostare quando desiderano bloccare gli orientamenti, invece di fare affidamento sul delegato dell'app per trovarli iterando attraverso le visualizzazioni secondarie.

Swift 3, 4, 5

In AppDelegate:

/// set orientations you want to be allowed in this property by default
var orientationLock = UIInterfaceOrientationMask.all

func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
        return self.orientationLock
}

In qualche altra struct globale o classe helper, qui ho creato AppUtility:

struct AppUtility {

    static func lockOrientation(_ orientation: UIInterfaceOrientationMask) {
    
        if let delegate = UIApplication.shared.delegate as? AppDelegate {
            delegate.orientationLock = orientation
        }
    }

    /// OPTIONAL Added method to adjust lock and rotate to the desired orientation
    static func lockOrientation(_ orientation: UIInterfaceOrientationMask, andRotateTo rotateOrientation:UIInterfaceOrientation) {
   
        self.lockOrientation(orientation)
    
        UIDevice.current.setValue(rotateOrientation.rawValue, forKey: "orientation")
        UINavigationController.attemptRotationToDeviceOrientation()
    }

}

Quindi nel ViewController desiderato si desidera bloccare gli orientamenti:

 override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    
    AppUtility.lockOrientation(.portrait)
    // Or to rotate and lock
    // AppUtility.lockOrientation(.portrait, andRotateTo: .portrait)
    
}

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    
    // Don't forget to reset when view is being removed
    AppUtility.lockOrientation(.all)
}

Se iPad o Universal App

Assicurati che "Richiede schermo intero" sia selezionato in Impostazioni di destinazione -> Generali -> Informazioni di distribuzione. supportedInterfaceOrientationsForil delegato non verrà chiamato se non è selezionato.

Question 3

Swift 4

AppDelegate

var orientationLock = UIInterfaceOrientationMask.all

func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
    return self.orientationLock
}
struct AppUtility {
    static func lockOrientation(_ orientation: UIInterfaceOrientationMask) {
        if let delegate = UIApplication.shared.delegate as? AppDelegate {
            delegate.orientationLock = orientation
        }
    }

    static func lockOrientation(_ orientation: UIInterfaceOrientationMask, andRotateTo rotateOrientation:UIInterfaceOrientation) {
        self.lockOrientation(orientation)
        UIDevice.current.setValue(rotateOrientation.rawValue, forKey: "orientation")
    }
}

Il tuo ViewController Aggiungi la seguente riga se hai bisogno solo dell'orientamento verticale. devi applicarlo a tutti i ViewController necessari per visualizzare la modalità verticale.

override func viewWillAppear(_ animated: Bool) {
AppDelegate.AppUtility.lockOrientation(UIInterfaceOrientationMask.portrait, andRotateTo: UIInterfaceOrientation.portrait)
    }

e questo farà l'orientamento dello schermo per gli altri Viewcontroller in base all'orientamento fisico del dispositivo.

override func viewWillDisappear(_ animated: Bool) {
        AppDelegate.AppUtility.lockOrientation(UIInterfaceOrientationMask.all)

    }

Question 4

Swift 3 e 4

Imposta la supportedInterfaceOrientationsproprietà di specifici UIViewControllers in questo modo:

class MyViewController: UIViewController {

    var orientations = UIInterfaceOrientationMask.portrait //or what orientation you want
    override var supportedInterfaceOrientations : UIInterfaceOrientationMask {
    get { return self.orientations }
    set { self.orientations = newValue }
    }

    override func viewDidLoad() {
        super.viewDidLoad()
    }

    //...
}

AGGIORNARE

Questa soluzione funziona solo quando il tuo nonviewController è incorporato , perché l'orientamento eredita dal viewController genitore. In questo caso, è possibile creare una sottoclasse e impostare queste proprietà su di essa.UINavigationController
UINavigationViewController

Question 5

Aggiungi questo codice per forzare il ritratto e bloccarlo:

override func viewDidLoad() {
    super.viewDidLoad()

    // Force the device in portrait mode when the view controller gets loaded
    UIDevice.currentDevice().setValue(UIInterfaceOrientation.Portrait.rawValue, forKey: "orientation") 
}

override func shouldAutorotate() -> Bool {
    // Lock autorotate
    return false
}

override func supportedInterfaceOrientations() -> Int {

    // Only allow Portrait
    return Int(UIInterfaceOrientationMask.Portrait.rawValue)
}

override func preferredInterfaceOrientationForPresentation() -> UIInterfaceOrientation {

    // Only allow Portrait
    return UIInterfaceOrientation.Portrait
}

Nella tua AppDelegate - imposta supportedInterfaceOrientationsForWindow su qualunque orientamento desideri che l'intera applicazione supporti:

func application(application: UIApplication, supportedInterfaceOrientationsForWindow window: UIWindow?) -> UIInterfaceOrientationMask {
    return UIInterfaceOrientationMask.All
}

Question 6

Questa è una soluzione generica per il tuo problema e altri correlati.

1. Crea la classe ausiliaria UIHelper e utilizza i seguenti metodi:

    /**This method returns top view controller in application  */
    class func topViewController() -> UIViewController?
    {
        let helper = UIHelper()
        return helper.topViewControllerWithRootViewController(rootViewController: UIApplication.shared.keyWindow?.rootViewController)
    }

    /**This is a recursive method to select the top View Controller in a app, either with TabBarController or not */
    private func topViewControllerWithRootViewController(rootViewController:UIViewController?) -> UIViewController?
    {
        if(rootViewController != nil)
        {
            // UITabBarController
            if let tabBarController = rootViewController as? UITabBarController,
                let selectedViewController = tabBarController.selectedViewController {
                return self.topViewControllerWithRootViewController(rootViewController: selectedViewController)
            }

            // UINavigationController
            if let navigationController = rootViewController as? UINavigationController ,let visibleViewController = navigationController.visibleViewController {
                return self.topViewControllerWithRootViewController(rootViewController: visibleViewController)
            }

            if ((rootViewController!.presentedViewController) != nil) {
                let presentedViewController = rootViewController!.presentedViewController;
                return self.topViewControllerWithRootViewController(rootViewController: presentedViewController!);
            }else
            {
                return rootViewController
            }
        }

        return nil
    }

2. Crea un protocollo con il tuo comportamento desiderato, per il tuo caso specifico sarà ritratto.

orientamento del protocolloIsOnlyPortrait {}

Nota: se lo desideri, aggiungilo all'inizio della classe UIHelper.

3. Estendi il tuo View Controller

Nel tuo caso:

class Any_ViewController: UIViewController,orientationIsOnlyPortrait {

   ....

}

4. Nella classe del delegato dell'app aggiungere questo metodo:

 func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
        let presentedViewController = UIHelper.topViewController()
        if presentedViewController is orientationIsOnlyPortrait {
            return .portrait
        }
        return .all
    }

Note finali:

Se quella classe più è in modalità verticale, estendi semplicemente quel protocollo.
Se desideri altri comportamenti dai controller di visualizzazione, crea altri protocolli e segui la stessa struttura.
Questo esempio risolve il problema con le modifiche all'orientamento dopo il push dei controller di visualizzazione

Question 7

Un sacco di ottime risposte in questo thread, ma nessuna ha soddisfatto le mie esigenze. Ho un'app a schede con controller di navigazione in ogni scheda e una vista doveva ruotare, mentre le altre dovevano essere bloccate in verticale. Il controller di navigazione non stava ridimensionando correttamente le sue sottoview, per qualche motivo. Ho trovato una soluzione (in Swift 3) combinando con questa risposta ei problemi di layout sono scomparsi. Crea la struttura come suggerito da @bmjohns:

import UIKit

struct OrientationLock {

    static func lock(to orientation: UIInterfaceOrientationMask) {
        if let delegate = UIApplication.shared.delegate as? AppDelegate {
            delegate.orientationLock = orientation
        }
    }

    static func lock(to orientation: UIInterfaceOrientationMask, andRotateTo rotateOrientation: UIInterfaceOrientation) {
        self.lock(to: orientation)
        UIDevice.current.setValue(rotateOrientation.rawValue, forKey: "orientation")
    }
}

Quindi sottoclasse UITabBarController:

    import UIKit

class TabBarController: UITabBarController, UITabBarControllerDelegate {
    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
        self.delegate = self
    }

    func tabBarControllerSupportedInterfaceOrientations(_ tabBarController: UITabBarController) -> UIInterfaceOrientationMask {
        if tabBarController.selectedViewController is MyViewControllerNotInANavigationControllerThatShouldRotate {
            return .allButUpsideDown
        } else if let navController = tabBarController.selectedViewController as? UINavigationController, navController.topViewController is MyViewControllerInANavControllerThatShouldRotate {
            return .allButUpsideDown
        } else {
            //Lock view that should not be able to rotate
            return .portrait
        }
    }

    func tabBarController(_ tabBarController: UITabBarController, shouldSelect viewController: UIViewController) -> Bool {
        if viewController is MyViewControllerNotInANavigationControllerThatShouldRotate {
            OrientationLock.lock(to: .allButUpsideDown)
        } else if let navController = viewController as? UINavigationController, navController.topViewController is MyViewControllerInANavigationControllerThatShouldRotate {
            OrientationLock.lock(to: .allButUpsideDown)
        } else {
            //Lock orientation and rotate to desired orientation
            OrientationLock.lock(to: .portrait, andRotateTo: .portrait)
        }
        return true
    }
}

Non dimenticare di cambiare la classe del TabBarController nello storyboard nella sottoclasse appena creata.

Question 8

Per una nuova versione di Swift, prova questo

override var shouldAutorotate: Bool {
    return false
}

override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return UIInterfaceOrientationMask.portrait
}

override var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
    return UIInterfaceOrientation.portrait
}

Question 9

Ecco un modo semplice che funziona per me con Swift 4.2 (iOS 12.2), inseriscilo in un UIViewControllerper il quale desideri disabilitare shouldAutorotate:

override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return .portrait
}

La .portraitparte dice in quale orientamento rimanere, puoi cambiarlo come preferisci. Le scelte sono: .portrait, .all, .allButUpsideDown, .landscape, .landscapeLeft, .landscapeRight, .portraitUpsideDown.

Question 10

Per impostare l'orientamento orizzontale su tutte le visualizzazioni della tua app e consentire una sola visualizzazione su Tutti gli orientamenti (per poter aggiungere il rullino della fotocamera, ad esempio):

In AppDelegate.swift:

var adaptOrientation = false

In: didFinishLaunchingWithOptions

NSNotificationCenter.defaultCenter().addObserver(self, selector: "adaptOrientationAction:", name:"adaptOrientationAction", object: nil)

Altrove in AppDelegate.swift:

func application(application: UIApplication, supportedInterfaceOrientationsForWindow window: UIWindow?) -> Int {
    return checkOrientation(self.window?.rootViewController)
}

func checkOrientation(viewController:UIViewController?)-> Int{
    if (adaptOrientation == false){
        return Int(UIInterfaceOrientationMask.Landscape.rawValue)
    }else {
        return Int(UIInterfaceOrientationMask.All.rawValue)
    }
}

func adaptOrientationAction(notification: NSNotification){
    if adaptOrientation == false {
        adaptOrientation = true
    }else {
        adaptOrientation = false
    }
}

Quindi nella vista che segue a quella che vuoi essere in grado di avere Tutti gli orientamenti:

override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject!) {
    if (segue.identifier == "YOURSEGUE") {
        NSNotificationCenter.defaultCenter().postNotificationName("adaptOrientationAction", object: nil)
    }
}

override func viewWillAppear(animated: Bool) {
    if adaptOrientation == true {
        NSNotificationCenter.defaultCenter().postNotificationName("adaptOrientationAction", object: nil)
    }
}

L'ultima cosa è spuntare Orientamento dispositivo: - Verticale - Orizzontale a sinistra - Orizzontale a destra

Question 11

Crea nuova estensione con

import UIKit

extension UINavigationController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return .portrait
    }
}

extension UITabBarController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return .portrait
    }
}

Question 12

bmjohns -> Sei il mio salvatore di vita. Questa è l'unica soluzione funzionante (con la struttura AppUtility)

Ho creato questa classe:

class Helper{
    struct AppUtility {

        static func lockOrientation(_ orientation: UIInterfaceOrientationMask) {

            if let delegate = UIApplication.shared.delegate as? AppDelegate {
                delegate.orientationLock = orientation
            }
        }

        /// OPTIONAL Added method to adjust lock and rotate to the desired orientation
        static func lockOrientation(_ orientation: UIInterfaceOrientationMask, andRotateTo rotateOrientation:UIInterfaceOrientation) {

            self.lockOrientation(orientation)

            UIDevice.current.setValue(rotateOrientation.rawValue, forKey: "orientation")
        }

    }
}

e seguito le tue istruzioni, e tutto funziona perfettamente per Swift 3 -> xcode versione 8.2.1

Question 13

A partire da iOS 10 e 11, iPad supporta Slide Over e Split View. Per abilitare un'app in Slide Over e Split View, è Requires full screen necessario deselezionare. Ciò significa che la risposta accettata non può essere utilizzata se l'app desidera supportare Slide Over e Split View. Scopri di più sui miglioramenti del multitasking di Apple su iPad qui .

Ho una soluzione che consente (1) deselezionare Requires full screen, (2) solo una funzione da implementare in appDelegate(soprattutto se non si desidera / non è possibile modificare i controller di visualizzazione di destinazione) e (3) evitare chiamate ricorsive. Non c'è bisogno di classe helper né estensioni.

appDelegate.swift (Swift 4)

func application(_ application: UIApplication,
                 supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
    // Search for the visible view controller
    var vc = window?.rootViewController
    // Dig through tab bar and navigation, regardless their order 
    while (vc is UITabBarController) || (vc is UINavigationController) {
        if let c = vc as? UINavigationController {
            vc = c.topViewController
        } else if let c = vc as? UITabBarController {
            vc = c.selectedViewController
        }
    }
    // Look for model view controller
    while (vc?.presentedViewController) != nil {
        vc = vc!.presentedViewController
    }
    print("vc = " + (vc != nil ? String(describing: type(of: vc!)) : "nil"))
    // Final check if it's our target class.  Also make sure it isn't exiting.
    // Otherwise, system will mistakenly rotate the presentingViewController.
    if (vc is TargetViewController) && !(vc!.isBeingDismissed) {
        return [.portrait]
    }
    return [.all]
}

modificare

@bmjohns ha sottolineato che questa funzione non è chiamata su iPad. Ho verificato e sì, non è stato chiamato. Quindi, ho fatto un po 'più di test e ho scoperto alcuni fatti:

Ho deselezionato Requires full screenperché desidero abilitare Slide Over e Slide View su iPad. Ciò richiede l'applicazione per supportare tutti i 4 orientamento per iPad, in Info.plist: Supported interface orientations (iPad).

La mia app funziona allo stesso modo di Facebook: su iPhone, la maggior parte delle volte è bloccata in verticale. Durante la visualizzazione dell'immagine a schermo intero, consente agli utenti di ruotare il paesaggio per una migliore visualizzazione. Su iPad, gli utenti possono ruotare in qualsiasi orientamento in qualsiasi controller di visualizzazione. Quindi, l'app sembra carina quando l'iPad è posizionato su Smart Cover (orizzontale a sinistra).

Affinché iPad possa chiamare application(_:supportedInterfaceOrientationsFor), in Info.plist, mantieni il ritratto solo per iPad. L'app perderà la capacità Slide Over + Split View. Ma puoi bloccare o sbloccare l'orientamento per qualsiasi controller di visualizzazione, in un solo posto e senza bisogno di modificare la classe ViewController.
Infine, questa funzione viene richiamata durante il ciclo di vita del controller di visualizzazione, quando la visualizzazione viene visualizzata / rimossa. Se la tua app deve bloccare / sbloccare / modificare l'orientamento in un altro momento, potrebbe non funzionare

Question 14

Soluzione testata effettiva per questo Nel mio esempio ho bisogno che l'intera app sia in modalità verticale, ma solo l'orientamento di uno schermo dovrebbe essere in modalità orizzontale.

Codice in AppDelegate come sopra le risposte descritte.

var orientationLock = UIInterfaceOrientationMask.all

func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask 
{
  return self.orientationLock
}
struct AppUtility {  

static func lockOrientation(_ orientation: UIInterfaceOrientationMask) {
    if let delegate = UIApplication.shared.delegate as? AppDelegate {
        delegate.orientationLock = orientation
    }
}
static func lockOrientation(_ orientation: UIInterfaceOrientationMask, andRotateTo rotateOrientation:UIInterfaceOrientation) {
self.lockOrientation(orientation)     
UIDevice.current.setValue(rotateOrientation.rawValue, forKey: "orientation")
}  
}

Quindi annota questo codice prima che il tuo viewcontroller con orientamento orizzontale venga presentato / push.

override func viewWillAppear(_ animated: Bool) {  
super.viewWillAppear(animated)
AppDelegate.AppUtility.lockOrientation(UIInterfaceOrientationMask.portrait, andRotateTo: UIInterfaceOrientation.portrait)
}

Quindi annota questo codice nel viewcontroller effettivo (per la visualizzazione orizzontale)

override func viewWillAppear(_ animated: Bool) {  
super.viewWillAppear(animated)
AppDelegate.AppUtility.lockOrientation(UIInterfaceOrientationMask.landscape, andRotateTo: UIInterfaceOrientation.landscape)
}

Question 15

Ho sperimentato un po 'e sono riuscito a trovare una soluzione pulita per questo problema. L'approccio si basa sul tagging della vista tramite tag view->

Nel ViewController di destinazione è sufficiente assegnare il tag alla vista radice come nel seguente esempio di codice:

class MyViewController: BaseViewController {

  // declare unique view tag identifier
  static let ViewTag = 2105981;

  override func viewDidLoad()
  {
    super.viewDidLoad();
    // assign the value to the current root view
    self.view.tag = MyViewController.ViewTag;
  }

E infine in AppDelegate.swift controlla se la vista attualmente mostrata è quella che abbiamo taggato:

func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask
{
    if (window?.viewWithTag(DesignerController.ViewTag)) != nil {
        return .portrait;
    }
    return .all;
}

Questo approccio è stato testato con il mio simulatore e sembra che funzioni bene.

Nota: la vista contrassegnata verrà trovata anche se l'MVC corrente è sovrapposto a un ViewController figlio nello stack di navigazione.

Question 16

Grazie alla risposta di @ bmjohn sopra. Ecco una versione Xamarin / C # funzionante del codice di quella risposta, per risparmiare ad altri il tempo della trascrizione:

AppDelegate.cs

 public UIInterfaceOrientationMask OrientationLock = UIInterfaceOrientationMask.All;
 public override UIInterfaceOrientationMask GetSupportedInterfaceOrientations(UIApplication application, UIWindow forWindow)
 {
     return this.OrientationLock;
 }

Static OrientationUtility.cs classe:

public static class OrientationUtility
{
    public static void LockOrientation(UIInterfaceOrientationMask orientation)
    {
        var appdelegate = (AppDelegate) UIApplication.SharedApplication.Delegate;
        if(appdelegate != null)
        {
            appdelegate.OrientationLock = orientation;
        }
    }

    public static void LockOrientation(UIInterfaceOrientationMask orientation, UIInterfaceOrientation RotateToOrientation)
    {
        LockOrientation(orientation);

        UIDevice.CurrentDevice.SetValueForKey(new NSNumber((int)RotateToOrientation), new NSString("orientation"));
    }
}

Visualizza controller:

    public override void ViewDidAppear(bool animated)
    {
       base.ViewWillAppear(animated);
       OrientationUtility.LockOrientation(UIInterfaceOrientationMask.Portrait, UIInterfaceOrientation.Portrait);
    }

    public override void ViewWillDisappear(bool animated)
    {
        base.ViewWillDisappear(animated);
        OrientationUtility.LockOrientation(UIInterfaceOrientationMask.All);
    }

Question 17

La migliore soluzione per bloccare e modificare l'orientamento in verticale e in orizzontale:

Guarda questo video su YouTube:

https://m.youtube.com/watch?v=4vRrHdBowyo

Questo tutorial è migliore e semplice.

o usa il codice seguente:

Guarda questa foto

// 1- nel secondo viewcontroller impostiamo landscapeleft e nel primo viewcontroller impostiamo portrat:

// 2- se usi NavigationController, dovresti aggiungere l'estensione

import UIKit

class SecondViewController: UIViewController {


    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        UIDevice.current.setValue(UIInterfaceOrientation.landscapeLeft.rawValue, forKey: "orientation")
    }

    override open var shouldAutorotate: Bool {
        return false
    }

    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return .landscapeLeft
    }

    override var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
        return .landscapeLeft
    }
    
    

    override func viewDidLoad() {
        super.viewDidLoad()
    }

//write The rest of your code in here


}

//if you use NavigationController, you should add this extension

extension UINavigationController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return topViewController?.supportedInterfaceOrientations ?? .allButUpsideDown
    
    }
}