Comment verrouiller l'orientation de l'une-vue-contrôleur en mode portrait uniquement en Swift

Les choses peuvent devenir assez désordonné lorsque vous avez un complexe de vue de la hiérarchie, comme le fait d'avoir plusieurs manettes de navigation et/ou l'onglet de la vue des contrôleurs.

Cette mise en place sur la vue individuelle contrôleurs de jeu quand ils voudraient verrouillage des orientations, au lieu de s'appuyer sur l'App Délégué à les trouver en parcourant les sous-vues.

Swift 3 & 4

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 certains autres struct global ou l'accompagnateur de la classe, ici j'ai créé 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()
    }

}

Puis le ViewController vous souhaitez verrouiller 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 l'iPad ou de l'Application Universelle

Assurez-vous que "plein écran" est cochée dans les Paramètres de la Cible -> Général> Déploiement d'Info. supportedInterfaceOrientationsFor délégué sera pas appelée si ce n'est pas cochée.

Ajouter ce code à la force de portrait et de 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 - set supportedInterfaceOrientationsForwindow à ce que les orientations de l'ensemble de la demande de soutien:

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

Une poignée de bonnes réponses dans ce thread, mais aucun ne correspondait tout à fait à mes besoins. J'ai des onglets d'application avec les contrôleurs de la navigation dans chaque onglet, et d'un point de vue nécessaire pour faire tourner, tandis que les autres devaient être verrouillé en mode portrait. La manette de navigation n'était pas le redimensionnement de la sous-vues correctement, pour une raison quelconque. Trouvé une solution (en Swift 3), en se combinant avec cette réponse, et la mise en page des questions disparu. Créer la structure comme le suggèrent 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 une 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
    }
}

Ne pas oublier de changer la classe de l'TabBarController dans le storyboard pour le nouvellement créé sous-classe.

Swift 3 & 4

Définir la supportedInterfaceOrientations propriété de certains UIViewControllers 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()
    }

    //...
}

Que de iOS 10 et 11, l'iPad prend en charge le Glisser Sur et Vue partagée. Afin de permettre une application à Glisser Sur et en mode Split, Requires full screen doit être décochée. Cela signifie que l'on a accepté la réponse ne peut pas être utilisé si l'application souhaite soutenir le Glisser Sur et Vue partagée. Voir plus d'Apple, l'Adoption de Multitâche Améliorations sur iPad ici.

J'ai une solution qui permet (1) de la désactivation de Requires full screen, (2) qu'une fonction à être mis en œuvre dans appDelegate (surtout si vous ne voulez pas /ne pouvez pas modifier la vue cible des contrôleurs), et (3) d'éviter les appels récursifs. Pas besoin de l'aide de la classe, ni les 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]
}

Modifier

@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é. Donc, j'ai fait un peu plus de tests et découvert quelques faits:

1. J'ai décoché Requires full screen parce que je veux activer le Glisser Sur et faites Glisser la Vue sur l'iPad. Qui nécessite l'application de soutenir tous les 4 orientation pour l'iPad, en Info.plist: Supported interface orientations (iPad).

Mon application fonctionne même manière que Facebook: sur l'iPhone, la plupart du temps, il est immobilisé à portrait. Lors de la visualisation d'une image en plein écran, permet aux utilisateurs de faire pivoter le paysage pour mieux voir. Sur iPad, les utilisateurs peuvent tourner à n'importe quelle orientation dans n'importe quelle vue des contrôleurs. Donc, l'appli a l'air sympa lorsque l'iPad est sur Smart Cover (paysage à gauche).

1. Pour iPad appeler application(_:supportedInterfaceOrientationsFor), en Info.plist, seulement de garder portrait pour l'iPad. L'application va perdre le Glisser Sur + la Vue Fractionnée de capacité. Mais vous pouvez verrouiller ou déverrouiller l'orientation pour tous-vue-contrôleur, en un seul endroit et pas besoin de modifier le ViewController classe.

2. Enfin, cette fonction appelée sur la vue du contrôleur de cycle de vie, lorsque la vue est affichée/supprimé. Si votre application a besoin de verrouiller/déverrouiller/changer d'orientation en d'autres temps, il pourrait ne pas fonctionner

Grâce à @bmjohn la réponse ci-dessus. Ici, c'est un travail Xamarin /C# version de la réponse du code, pour en sauver d'autres, le temps de la transcription:

AppDelegate.cs

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

Statique OrientationUtility.cs de la 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"));
    }
}

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

Voici une méthode simple qui fonctionne pour moi avec Swift 4.2 (iOS 12.2), mettre cela dans une UIViewController pour lequel vous souhaitez désactiver shouldAutorotate:

override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return .portrait
}

La .portrait partie raconte dans lequel orientation(s) de rester, vous pouvez modifier ce que vous voulez. Les choix sont: .portrait, .all, .allButUpsideDown, .landscape, .landscapeLeft, .landscapeRight, .portraitUpsideDown.