Comment verrouiller l'orientation d'un contrôleur de vue en mode portrait uniquement dans Swift

Depuis que mon application est prise en charge pour toutes les orientations. Je voudrais verrouiller uniquement le mode portrait sur un UIViewController spécifique.

Par exemple, supposons qu'il s'agissait d'une application à onglets et lorsque la vue de connexion apparaît de manière modale, je souhaite uniquement que la vue de connexion soit en mode portrait, peu importe la façon dont l'utilisateur fait pivoter l'appareil ou l'orientation actuelle de l'appareil.

Les choses peuvent devenir assez compliquées lorsque vous avez une hiérarchie de vues compliquée, comme avoir plusieurs contrôleurs de navigation et / ou contrôleurs de vue par onglets.

Cette implémentation permet aux contrôleurs de vue individuels de définir quand ils souhaitent verrouiller les orientations, au lieu de compter sur le délégué d'application pour les trouver en itérant dans les sous-vues.

Swift 3, 4, 5

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

Dans une autre structure globale ou classe d'assistance, j'ai créé ici 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()
    }

}

Ensuite, dans le ViewController souhaité, vous souhaitez verrouiller les orientations:

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

Si iPad ou application universelle

Assurez-vous que "Nécessite un plein écran" est coché dans Paramètres cible -> Général -> Informations de déploiement. supportedInterfaceOrientationsForLe délégué ne sera pas appelé si cela n'est pas coché.

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")
    }
}

Votre ViewController Ajoutez la ligne suivante si vous n'avez besoin que d'une orientation portrait. vous devez l'appliquer à tous les besoins de ViewController pour afficher le mode portrait.

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

et cela fera l'orientation de l'écran pour les autres Viewcontroller en fonction de l'orientation physique de l'appareil.

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

    }

Swift 3 et 4

Définissez la supportedInterfaceOrientationspropriété de UIViewControllers spécifiques comme ceci:

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

    //...
}

METTRE À JOUR

Cette solution ne fonctionne que lorsque votre viewControllern'est pas incorporé dans UINavigationController, car l'orientation hérite de viewController parent.
Dans ce cas, vous pouvez créer une sous-classe de UINavigationViewControlleret définir ces propriétés dessus.

Ajoutez ce code pour forcer le portrait et le verrouiller:

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
}

Dans votre AppDelegate - définissez supportedInterfaceOrientationsForWindow sur les orientations que vous souhaitez que l'application entière prenne en charge:

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

Ceci est une solution générique pour votre problème et d'autres connexes.

1. Créez la classe auxiliaire UIHelper et appliquez les méthodes suivantes:

    /**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. Créez un protocole avec votre comportement de désir, car votre cas spécifique sera portrait.

orientation du protocoleIsOnlyPortrait {}

Nota: si vous le souhaitez, ajoutez-le en haut de la classe UIHelper.

3. Étendez votre View Controller

Dans ton cas:

class Any_ViewController: UIViewController,orientationIsOnlyPortrait {

   ....

}

4. Dans la classe de délégué d'application, ajoutez cette méthode:

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

Notes finales:

• Si vous êtes en mode portrait, étendez simplement ce protocole.
• Si vous voulez d'autres comportements des contrôleurs de vue, créez d'autres protocoles et suivez la même structure.
• Cet exemple résout le problème des changements d'orientation après les contrôleurs de vue push

Un tas de bonnes réponses dans ce fil, mais aucune ne correspondait tout à fait à mes besoins. J'ai une application à onglets avec des contrôleurs de navigation dans chaque onglet, et une vue doit pivoter, tandis que les autres doivent être verrouillées en portrait. Le contrôleur de navigation ne redimensionnait pas correctement ses sous-vues, pour une raison quelconque. J'ai trouvé une solution (dans Swift 3) en la combinant avec cette réponse, et les problèmes de mise en page ont disparu. Créez la structure comme suggéré par @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")
    }
} 

Puis sous-classe 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
    }
}

N'oubliez pas de changer la classe de TabBarController dans le storyboard en sous-classe nouvellement créée.

Pour une nouvelle version de Swift, essayez ceci

override var shouldAutorotate: Bool {
    return false
}

override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return UIInterfaceOrientationMask.portrait
}

override var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
    return UIInterfaceOrientation.portrait
}

Voici un moyen simple qui fonctionne pour moi avec Swift 4.2 (iOS 12.2), mettez ceci dans un UIViewControllerpour lequel vous souhaitez désactiver shouldAutorotate:

override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return .portrait
}

La .portraitpièce lui indique dans quelle (s) orientation (s) rester, vous pouvez changer cela comme vous le souhaitez. Les choix sont: .portrait, .all, .allButUpsideDown, .landscape, .landscapeLeft, .landscapeRight, .portraitUpsideDown.

Pour définir l'orientation Paysage sur toutes les vues de votre application et autoriser une seule vue sur Toutes les orientations (pour pouvoir ajouter une pellicule par exemple):

Dans AppDelegate.swift:

var adaptOrientation = false

Dans: didFinishLaunchingWithOptions

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

Ailleurs dans 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
    }
}

Ensuite, dans la vue qui passe à celle que vous voulez pouvoir avoir Toutes les orientations:

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

La dernière chose à faire est de cocher Orientation de l'appareil: - Portrait - Paysage à gauche - Paysage à droite

Créer une nouvelle extension avec

import UIKit

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

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

bmjohns -> Vous êtes mon sauveur de vie. C'est la seule solution de travail (avec la structure AppUtility)

J'ai créé cette 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")
        }

    }
}

et suivi vos instructions, et tout fonctionne parfaitement pour Swift 3 -> xcode version 8.2.1

À partir d'iOS 10 et 11, l'iPad prend en charge Slide Over et Split View. Pour activer une application dans Slide Over et Split View, Requires full screen doit être décochée. Cela signifie que la réponse acceptée ne peut pas être utilisée si l'application souhaite prendre en charge Slide Over et Split View. En savoir plus sur l' adoption des améliorations multitâches d'Apple sur iPad ici .

J'ai une solution qui permet (1) de décocher Requires full screen, (2) une seule fonction à implémenter dansappDelegate (surtout si vous ne voulez / ne pouvez pas modifier les contrôleurs de vue cible), et (3) éviter les appels récursifs. Pas besoin de classe d'assistance ni d'extensions.

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

Éditer

@bmjohns a souligné que cette fonction n'est pas appelée sur iPad. J'ai vérifié et oui, il n'a pas été appelé. J'ai donc fait un peu plus de tests et découvert quelques faits:

1. J'ai décoché Requires full screencar je souhaite activer le diaporama et l'affichage des diapositives sur iPad. Cela exige l'application pour soutenir toutes les orientations 4 pour iPad, en Info.plist: Supported interface orientations (iPad).

Mon application fonctionne de la même manière que Facebook: sur iPhone, la plupart du temps, elle est verrouillée en mode portrait. Lors de la visualisation de l'image en plein écran, permet aux utilisateurs de faire pivoter le paysage pour une meilleure vue. Sur iPad, les utilisateurs peuvent choisir n'importe quelle orientation dans n'importe quel contrôleur de vue. Ainsi, l'application a l'air bien lorsque l'iPad est sur Smart Cover (paysage à gauche).

2. Pour que l'iPad puisse appeler application(_:supportedInterfaceOrientationsFor), dans Info.plist, ne conservez que portrait pour iPad. L'application perdra la capacité Slide Over + Split View. Mais vous pouvez verrouiller ou déverrouiller l'orientation de n'importe quel contrôleur de vue, à un seul endroit et sans avoir besoin de modifier la classe ViewController.

3. Enfin, cette fonction est appelée lors du cycle de vie du contrôleur de vue, lorsque la vue est affichée / supprimée. Si votre application doit verrouiller / déverrouiller / modifier l'orientation à un autre moment, cela peut ne pas fonctionner

Solution réelle testée pour cela.Dans mon exemple, j'ai besoin que toute mon application soit en mode portrait, mais une seule orientation d'écran doit être en mode paysage.

Code dans AppDelegate comme décrit ci-dessus.

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")
}  
}

Ensuite, écrivez ce code avant que votre contrôleur de vue d'orientation paysage ne soit présenté / push.

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

Puis écrivez ce code dans le viewcontroller réel (pour la vue paysage)

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

J'ai expérimenté un peu et j'ai réussi à trouver une solution propre à ce problème. L'approche est basée sur le balisage de vue via view-> tag

Dans le ViewController cible, affectez simplement la balise à la vue racine comme dans l'exemple de code suivant:

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

Et enfin, dans AppDelegate.swift, vérifiez si la vue actuellement affichée est celle que nous avons taguée:

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

Cette approche a été testée avec mon simulateur et semble fonctionner correctement.

Remarque: la vue marquée sera également trouvée si le MVC actuel est superposé avec un ViewController enfant dans la pile de navigation.

Merci à la réponse de @ bmjohn ci-dessus. Voici une version Xamarin / C # fonctionnelle du code de cette réponse, pour économiser aux autres le temps de transcription:

AppDelegate.cs

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

Classe statique OrientationUtility.cs:

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

Voir le contrôleur:

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

Meilleure solution pour verrouiller et modifier l'orientation en mode portrait et paysage:

Regardez cette vidéo sur YouTube:

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

Ce tutoriel est meilleur et simple.

ou utilisez le code ci-dessous:

Voir cette photo

// 1- dans le second viewcontroller, nous définissons paysage à gauche et dans le premier viewcontroller, nous définissons portrat:

// 2- si vous utilisez NavigationController, vous devez ajouter l'extension

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