Force landscape mode in one ViewController using Swift

Question

I am trying to force only one view in my application on landscape mode, I am calling:

override func shouldAutorotate() -> Bool {
    print("shouldAutorotate")
    return false
}

override func supportedInterfaceOrientations() -> Int {
    print("supportedInterfaceOrientations")
    return Int(UIInterfaceOrientationMask.LandscapeLeft.rawValue)
}

override func preferredInterfaceOrientationForPresentation() -> UIInterfaceOrientation {
    return UIInterfaceOrientation.LandscapeLeft
}

The view is launched in the portrait mode, and keep rotating when I change the device orientation. The shouldAutorotate() method is never called.

Any help would be appreciated.

Possible duplicate of [How to force view controller orientation in iOS 8?](https://stackoverflow.com/questions/26357162/how-to-force-view-controller-orientation-in-ios-8) — hbk, Sep 29 '17 at 21:23

score 89 · Accepted Answer · edited Mar 08 '19 at 16:20

89

It may be useful for others, I found a way to force the view to launch in landscape mode:

Put this in the viewDidLoad():

let value = UIInterfaceOrientation.landscapeLeft.rawValue
UIDevice.current.setValue(value, forKey: "orientation")

and,

override var shouldAutorotate: Bool {
    return true
}

edited Mar 08 '19 at 16:20

Tung Fam

7,899
4
56
63

answered Nov 21 '14 at 10:01

sazz

3,193
3
23
33

6

I’ve just tried using this and it didn’t work; although changing shouldAutorotate() to return false worked. Just to be clear: I wanted it to stay in Portrait no matter what. (Also changed UIInterfaceOrientation.LandscapeLeft to UIInterfaceOrientation.Portrait of course) – milo526 Mar 12 '15 at 21:49
2

it's because your view load in Portrait mode and you want it to stay like that, my view load in Portrait mode and I want it to show in Landscape mode. If I put shouldAutorotate to NO, it will not show in Landscape – sazz Mar 13 '15 at 08:39
Thanks!! This worked great for me on an iOS9 app with Swift 2.2 to force portrait. I started with a 'parent' view in landscape, put the above code in viewDidLoad of the ViewController which i present modally from the 'parent', and when the modal view was presented, the view rotated to portrait. When i dismissed the modal view, the 'parent' remained in portrait (though i bet you could store a 'previous orientation' value before showing the modal and set the 'parent' view back to the previous orientation, if you wanted to swanky about it! – Natalia May 19 '16 at 01:32
5

Could this cause Apple to reject your app? orientation is a readonly property, and you're manipulating the value. I would think Apple would frown upon this. – pulse4life Sep 26 '16 at 14:00
If the device was initially oriented LandscapeRight, would you really want everything to suddenly appear upside down? – Edward Brey Sep 12 '17 at 09:58
1

worked for me on iOS 14, Swift 5.3, only by overriding shouldAutorotate. – quarac Sep 29 '20 at 19:03

score 68 · Answer 2 · edited Dec 26 '19 at 18:56

Swift 4

override func viewDidLoad() {
    super.viewDidLoad()
    let value = UIInterfaceOrientation.landscapeLeft.rawValue
    UIDevice.current.setValue(value, forKey: "orientation")
}

override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return .landscapeLeft
}

override var shouldAutorotate: Bool {
    return true
}

If your view is embedded in a navigation controller, the above alone won't work. You have to cascade up by the following extension after the class definition.

extension UINavigationController {

override open var shouldAutorotate: Bool {
    get {
        if let visibleVC = visibleViewController {
            return visibleVC.shouldAutorotate
        }
        return super.shouldAutorotate
    }
}

override open var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation{
    get {
        if let visibleVC = visibleViewController {
            return visibleVC.preferredInterfaceOrientationForPresentation
        }
        return super.preferredInterfaceOrientationForPresentation
    }
}

override open var supportedInterfaceOrientations: UIInterfaceOrientationMask{
    get {
        if let visibleVC = visibleViewController {
            return visibleVC.supportedInterfaceOrientations
        }
        return super.supportedInterfaceOrientations
    }
}}

Swift 3

override func viewDidLoad() {
    super.viewDidLoad()
    let value = UIInterfaceOrientation.landscapeLeft.rawValue
    UIDevice.current.setValue(value, forKey: "orientation")
}

private func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
    return UIInterfaceOrientationMask.landscapeLeft
}

private func shouldAutorotate() -> Bool {
    return true
}

This code doesn't work on iOS 12. App gets crash and shows the error like "Supported orientations has no common orientation with the application and [PlayerViewController shouldAutorotate] is returning YES" — Mayur Rathod, Oct 19 '18 at 09:14
@Shirish Yes I implemented orientation change code in delegate file — Mayur Rathod, Jan 22 '19 at 10:21
@MayurRathod If you have time, could you please post your answer — Mark, Apr 04 '19 at 01:38
The Solution works fine for the iPhone but in iPad the presenting controller and hence the entire App is oriented to landscape. Any idea where can I be wrong? — user550088, Apr 08 '20 at 23:51

Zeesha · Answer 3 · 2019-02-04T10:32:37.700

38

Swift 4 , Tested in iOS 11

You can specify the orientation in projectTarget -> General -> DeploymentInfo(Device Orientation) -> Portrait (Landscapeleft and Landscaperight are optional)

AppDelegate

    var myOrientation: UIInterfaceOrientationMask = .portrait
    func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
        return myOrientation
    }

LandScpaeViewController

override func viewDidLoad() {
        super.viewDidLoad()
        let appDelegate = UIApplication.shared.delegate as! AppDelegate
        appDelegate.myOrientation = .landscape
}

OnDismissButtonTap

let appDelegate = UIApplication.shared.delegate as! AppDelegate
 appDelegate.myOrientation = .portrait

Thats it. :)

edited Feb 04 '19 at 10:32

answered Oct 27 '17 at 04:37

Zeesha

991
9
14

3

supportedInterfaceOrientationsFor is getting called only if device is rotated once. – Naga Mallesh Maddali Dec 19 '17 at 12:06
This is what I've been looking for, thanks! For anyone wondering the difference, this will present the new view in the rotation without animation. Where as setting the orientation on UIDevice will add a default rotation animation. – PostCodeism Aug 23 '20 at 21:20
omg yess!! this works pretty well, thank you! – JJ S. Aug 13 '21 at 15:50

score 22 · Answer 4 · answered Jun 06 '16 at 14:42

Using Swift 2.2

Try:

let value = UIInterfaceOrientation.LandscapeLeft.rawValue
UIDevice.currentDevice().setValue(value, forKey: "orientation")

Followed By:

UIViewController.attemptRotationToDeviceOrientation()

From Apple's UIViewController Class Reference:

Some view controllers may want to use app-specific conditions to determine what interface orientations are supported. If your view controller does this, when those conditions change, your app should call this class method. The system immediately attempts to rotate to the new orientation.

Then, as others have suggested, override the following methods as appropriate:

override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
    return UIInterfaceOrientationMask.LandscapeLeft
}

override func shouldAutorotate() -> Bool {
    return true
}

I was having a similar issue with a signature view and this solved it for me.

Thanks for this answer man, This comment > `UIViewController.attemptRotationToDeviceOrientation()` Is very important because sometimes controller does not know if the rotation is to be performed or not. But this tells it to perform the rotation accordingly. — Ramandeep Singh Gosal, Jun 05 '18 at 06:20

score 21 · Answer 5 · edited Nov 15 '19 at 06:58

21

In AppDelegate add this:

//Orientation Variables
var myOrientation: UIInterfaceOrientationMask = .portrait

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

Add this in viewController, that want to change orientation:

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

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        self.rotateToPotraitScapeDevice()
    }

    func rotateToLandsScapeDevice(){
        let appDelegate = UIApplication.shared.delegate as! AppDelegate
        appDelegate.myOrientation = .landscapeLeft
        UIDevice.current.setValue(UIInterfaceOrientation.landscapeLeft.rawValue, forKey: "orientation")
        UIView.setAnimationsEnabled(true)
    }

    func rotateToPotraitScapeDevice(){
        let appDelegate = UIApplication.shared.delegate as! AppDelegate
        appDelegate.myOrientation = .portrait
        UIDevice.current.setValue(UIInterfaceOrientation.portrait.rawValue, forKey: "orientation")
        UIView.setAnimationsEnabled(true)
    }

edited Nov 15 '19 at 06:58

Luckabo

74
5

answered Apr 17 '19 at 08:25

Elangovan

1,158
1
9
26

1

Worked like a charm even after two and a half years later. Thanks. – Onur Şahindur Nov 27 '19 at 17:10
Perfect solution !! – nitin.agam Jul 09 '20 at 14:59
2

anybody experiencing a bug with this solution? If I rotate to landscape then select a different app on my device using App Task Manager then navigate back to my app, then click back. The orientation stays in landscape. – grantespo Oct 22 '20 at 21:10
@grantespo, I'm a bit late to the party, but I ran into that bug and fixed it by making changes to the calling ViewController. I overrode supportedInterfaceOrientation to .portrait and overrode shouldAutorotate to true. – Lastmboy May 25 '21 at 17:08
working for UIInterfaceOrientation.landscapeLeft not for UIInterfaceOrientation.landscapeRight – Vijay Parmar Nov 22 '21 at 06:43
1

this should be the accepted answer, thanks a lot – EnasAZ Feb 08 '22 at 02:42
@grantespo any solution of your bug? – Chetan Prajapati Aug 22 '22 at 13:40

score 18 · Answer 6 · edited Jan 28 '18 at 19:21

For me, the best results came from combining Zeesha's answer and sazz's answer.

Add the following lines to AppDelegate.swift:

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

Add the following line to your view controller class:

let appDel = UIApplication.shared.delegate as! AppDelegate

Add the following lines to your view controller's viewDidLoad():

appDel.myOrientation = .landscape
UIDevice.current.setValue(UIInterfaceOrientation.landscapeLeft.rawValue, forKey: "orientation")

(optional) Add this line to your dismiss function:

appDel.myOrientation = .portrait
UIDevice.current.setValue(UIInterfaceOrientation.portrait.rawValue, forKey: "orientation")

What these lines of code do is set the default orientation to portrait, rotate it landscape when the view controller loads, and then finally reset it back to portrait once the view controller closes.

This works for me too, because in my Project -> Deployment info I just have Portrait mode selected. Thanks — Dasoga, Aug 08 '18 at 03:39
I tried many methods over the years. This is by far the easiest solution, no iterating over all stacked controllers etc. Hope it will last :) — Oritm, Aug 24 '20 at 20:55

score 12 · Answer 7 · answered Mar 31 '20 at 10:33

12

Overwrite (in ViewController):

override public var shouldAutorotate: Bool {
    return false
} 

override public var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return .landscapeRight
}

override public var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
    return .landscapeRight
}

Hint for ios 13. As of ios 13, VC has different modalPresentationStyle as .automatic and device present modal view instead of Full-Screen VC. To fix this one must set modalPresentationStyle to .fullScreen. Example:

let viewController = YourViewController()
viewController.modalPresentationStyle = .fullScreen

answered Mar 31 '20 at 10:33

Yaroslav Havrylovych

766
8
21

4

viewController.modalPresentationStyle = .fullScreen helped me. Thanks! – anoo_radha Jul 31 '20 at 19:03
This only worked for me when the viewController is presented using `.present(viewController, animated: false, completion: nil)`.. NOT when pushing viewController using `.pushViewController(viewController, animated: true)` – YodagamaHeshan Nov 08 '21 at 02:24
This is partially work. BUT my case I've one navigation controller where I've presented landscape screen and when user switch to other app I need to present appLockScreen on another navigation controller (which works fine). Once user done with appLockScreen new navigation controller is dismissed and old landscaped screen is auto potraitted. :( – Chetan Prajapati Aug 22 '22 at 14:32

score 9 · Answer 8 · answered Nov 12 '17 at 14:31

9

I needed to force one controller into portrait orientation. Adding this worked for me.

swift 4 with iOS 11

override var   supportedInterfaceOrientations : UIInterfaceOrientationMask{

    return  .portrait

}

answered Nov 12 '17 at 14:31

Rob Schlackman

309
3
6

score 3 · Answer 9 · edited Oct 17 '19 at 07:04

I faced a similar issue in my project. It only has support for portrait. The ViewController structure is that, Navigation contained a controller (I called A), and a long Scrollview in A controller. I need A(portrait) present to B(landscape right).

In the beginning I tried the method below and it seemed to work but eventually I found a bug in it.

Swift 5 & iOS12

// In B controller just override three properties

override var shouldAutorotate: Bool {
    return false
}

override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return UIInterfaceOrientationMask.landscapeRight
}

override var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
    return .landscapeRight
}

And then something become strange. When controller B dismiss to controller A. The ScrollView in controller A has been slid some point.

So I used another method, so I rotate the screen when viewWillAppear. You can see the code for that below.

// In controller B
// not need override shouldAutorotate , supportedInterfaceOrientations , preferredInterfaceOrientationForPresentation

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    let appDel = UIApplication.shared.delegate as! AppDelegate
    appDel.currentOrientation = .landscapeRight
    UIDevice.current.setValue( UIInterfaceOrientation.landscapeRight.rawValue, forKey: "orientation")
    UIViewController.attemptRotationToDeviceOrientation()
}

//in viewWillDisappear rotate to portrait can not fix the bug


override func dismiss(animated flag: Bool, completion: (() -> Void)? = nil) {
    let appDel = UIApplication.shared.delegate as! AppDelegate
    appDel.currentOrientation = .portrait
    UIDevice.current.setValue( UIInterfaceOrientation.portrait.rawValue, forKey: "orientation")
    UIViewController.attemptRotationToDeviceOrientation() //must call 
    super.dismiss(animated: true, completion: nil)
}

// in AppDelegate
// the info plist is only supported portrait also, No need to change it

var currentOrientation : UIInterfaceOrientationMask = .portrait


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

can you create any example/demo on change orientation at button click? — Chandan Jee, Jan 22 '20 at 07:56

score 2 · Answer 10 · answered May 12 '16 at 13:46

Works in Swift 2.2

 func application(application: UIApplication, supportedInterfaceOrientationsForWindow window: UIWindow?) -> UIInterfaceOrientationMask {
    if self.window?.rootViewController?.presentedViewController is SignatureViewController {

        let secondController = self.window!.rootViewController!.presentedViewController as! SignatureViewController

        if secondController.isPresented {

            return UIInterfaceOrientationMask.LandscapeLeft;

        } else {

            return UIInterfaceOrientationMask.Portrait;
        }

    } else {

        return UIInterfaceOrientationMask.Portrait;
    }
}

Does the code above go in AppDelegate or just in the ViewController that you're trying to force to portrait? — Natalia, May 19 '16 at 01:21

score 2 · Answer 11 · edited Sep 11 '17 at 15:25

Swift 3. This locks the orientation each time the user re-opens the app.

class MyViewController: UIViewController {
    ...
    override func viewDidLoad() {
        super.viewDidLoad()

        // Receive notification when app is brought to foreground
        NotificationCenter.default.addObserver(self, selector: #selector(self.onDidBecomeActive), name: NSNotification.Name.UIApplicationDidBecomeActive, object: nil)
    }

    // Handle notification
    func onDidBecomeActive() {
        setOrientationLandscape()
    }

    // Change orientation to landscape
    private func setOrientationLandscape() {
        if !UIDevice.current.orientation.isLandscape {
            let value = UIInterfaceOrientation.landscapeLeft.rawValue
            UIDevice.current.setValue(value, forKey:"orientation")
            UIViewController.attemptRotationToDeviceOrientation()
        }
    }

    // Only allow landscape left
    override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return UIInterfaceOrientationMask.landscapeLeft
    }

    /*
    // Allow rotation - this seems unnecessary
    private func shouldAutoRotate() -> Bool {
        return true
    }
    */
    ...
}

score 2 · Answer 12 · answered Sep 29 '17 at 21:15

Swift 4

Trying to keep the orientation nothing worked but this for me:

...        
override func viewDidLoad() {
       super.viewDidLoad()
       forcelandscapeRight()
       let notificationCenter = NotificationCenter.default
       notificationCenter.addObserver(self, selector: #selector(forcelandscapeRight), name: Notification.Name.UIDeviceOrientationDidChange, object: nil)
    }

    @objc func forcelandscapeRight() {
        let value = UIInterfaceOrientation.landscapeRight.rawValue
        UIDevice.current.setValue(value, forKey: "orientation")
    }
....

score 2 · Answer 13 · answered Apr 07 '19 at 18:07

In ViewController in viewDidLoad Method call below function

func rotateDevice(){
    UIDevice.current.setValue(UIInterfaceOrientation.landscapeLeft.rawValue, forKey: "orientation")
    UIView.setAnimationsEnabled(true) // while rotating device it will perform the rotation animation
}`

App Delegate File Add Below Function & Variables

//Orientation Variables
var orientationLock = UIInterfaceOrientationMask.portrait
var myOrientation: UIInterfaceOrientationMask = .portrait

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

score 1 · Answer 14 · answered Nov 20 '14 at 11:58

1

According to the documentation of supportedInterfaceOrientations the shouldAutorotate method should return true or YES in Objective-C so that the supportedInterfaceOrientations are considered.

answered Nov 20 '14 at 11:58

Sebastian Wramba

10,087
8
41
58

score 1 · Answer 15 · answered Jul 19 '22 at 13:17

1

iOS 16+: `requestGeometryUpdate(_:errorHandler:)` API

As noted by @simonbs on Twitter, iOS 16 introduces a new API to update the current interface orientation. While in most cases, other, conventional methods will do the job, in some edge cases, they don't work (forcing the use of private APIs like suggested in this answer). Here, the new public API comes to the rescue.

The API works as follows:

windowScene.requestGeometryUpdate(.iOS(interfaceOrientations: .portrait))

You can optionally also pass a closure to handle errors (though I have no experience under which circumstances errors may occur):

windowScene.requestGeometryUpdate(.iOS(interfaceOrientations: .portrait)) { error in
   // Handle error...
}

answered Jul 19 '22 at 13:17

fredpi

8,414
5
41
61

2

iOS 16 Error encountered: ```Error Domain=UISceneErrorDomain Code=101 "None of the requested orientations are supported by the view controller. Requested: portrait; Supported: landscapeLeft, landscapeRight" UserInfo={NSLocalizedDescription=None of the requested orientations are supported by the view controller. Requested: portrait; Supported: landscapeLeft, landscapeRight}``` – iHTCboy Sep 07 '22 at 04:14
1

@fredpi thanks you for sharing. Will you please share how can I achieve this for iPhone single screen in landscape for UIWindow usage? – Chetan Prajapati Sep 15 '22 at 07:19

score 1 · Answer 16 · answered Jun 17 '23 at 05:59

Tested on IOS 13 to 16.4

First, create a protocol for your rotatable view controller:

protocol Rotatable:UIViewController{}

Then inside your add below code in your AppDelegate:

 func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
    guard let topVC = UIApplication.getTopViewController(base: window?.rootViewController) as? Rotatable else {
        return .portrait
    }
    guard !topVC.isModal else {
        //Use isBeingDismissed to prevent rotation glitches when changing the top view controller.
        return topVC.isBeingDismissed ? .portrait : topVC.supportedInterfaceOrientations
    }

    return topVC.supportedInterfaceOrientations
}

You also need the below extensions:

extension UIApplication {

    static func getTopViewController(base: UIViewController? = rootViewController) -> UIViewController? {
        
        if let nav = base as? UINavigationController {
            return getTopViewController(base: nav.visibleViewController)
        }

        if let tab = base as? UITabBarController {
            if let selected = tab.selectedViewController {
                return getTopViewController(base: selected)
            }
        }

        if let presented = base?.presentedViewController {
            return getTopViewController(base: presented)
        }

        return base
    }
    
    static var rootViewController:UIViewController?{
      return UIApplication
            .shared
            .connectedScenes
            .flatMap { ($0 as? UIWindowScene)?.windows ?? [] }
            .last { $0.isKeyWindow }?.rootViewController
    }

}


extension UIViewController{
    
    var isModal: Bool {

        let presentingIsModal = presentingViewController != nil
        let presentingIsNavigation = navigationController?.presentingViewController?.presentedViewController == navigationController
        let presentingIsTabBar = tabBarController?.presentingViewController is UITabBarController

        return presentingIsModal || presentingIsNavigation || presentingIsTabBar
    }
    
}

After that you just need to override the below variables in your view controllers:

class MyViewController: UIViewController,Rotatable {

     override var shouldAutorotate: Bool {
            return true
        }
        
     override public var supportedInterfaceOrientations: UIInterfaceOrientationMask {
            return .landscape
        }

}

Currently, this is the only answer working for me. All else is not working. — The iOSDev, Aug 07 '23 at 09:23

score 0 · Answer 17 · answered Nov 12 '18 at 13:25

My solution is

just added below codes in AppDelegate

enum PossibleOrientations {
  case portrait
    case landscape

    func o() -> UIInterfaceOrientationMask {
      switch self {
      case .portrait:
        return .portrait
      case .landscape:
        return .landscapeRight
      }
    }
}
var orientation: UIInterfaceOrientationMask = .portrait

func switchOrientation(to: PossibleOrientations) {
    let keyOrientation = "orientation"

    if to == .portrait && UIDevice.current.orientation.isPortrait {
        return
    } else if to == .landscape && UIDevice.current.orientation.isLandscape {
        return
    }

    switch to {
    case .portrait:
        orientation = .portrait
        UIDevice.current.setValue(UIInterfaceOrientation.portrait.rawValue, forKey: keyOrientation)
    case .landscape:
        orientation = .landscapeRight
        UIDevice.current.setValue(UIInterfaceOrientation.landscapeRight.rawValue, forKey: keyOrientation)
    }
}

And call below codes to change

override func viewDidLoad() {
    super.viewDidLoad()

    if let appDelegate = UIApplication.shared.delegate as? AppDelegate {
        appDelegate.switchOrientation(to: .landscape)
    }
}

or like below

@IBAction func actBack() {
    if let appDelegate = UIApplication.shared.delegate as? AppDelegate {
        appDelegate.switchOrientation(to: .portrait)
    }
    self.navigationController?.popViewController(animated: true)
}

score 0 · Answer 18 · edited Mar 23 '19 at 20:56

// below code put in view controller
// you can change landscapeLeft or portrait

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

override var shouldAutorotate: Bool {
        return true
    }
    override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return .landscapeRight
    }
    override var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
        return .landscapeRight
    }

Zenman C · Answer 19 · 2019-11-14T22:38:15.383

I tried many of the answers below but I'm afraid they didn't work. Especially if nav bars and tab bars are also implemented on the app. The solution that worked for me was provided by Sunny Lee on this post here: Sunny Lee, Medium post

Which in turn is an update of this post: Original solution

The only change I made when implementing the post's solution, was to change the part which references .allButUpsideDown to .landscapeleft

score 0 · Answer 20 · answered Dec 09 '19 at 16:10

In Xcode 11 with Swift 5 I Implemented the following. But it only works when the device orientation for the project target does not include all orientations. I disabled the check for Upside Down. After this, the following code works. If all checkboxes are enabled, the code is not called;

class MyController : UINavigationController {

    override var shouldAutorotate: Bool {
        return true
    }

    override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return .landscape
    }


}

score -2 · Answer 21 · answered May 20 '17 at 10:45

-2

class CustomUIViewController : UIViewController{

    override var   supportedInterfaceOrientations : UIInterfaceOrientationMask{

        return  .landscapeLeft

    }

}


class ViewController: CustomUIViewController {
.
.
.
}

answered May 20 '17 at 10:45

Tal

17

Welcome to stack overflow, how to write answer properly check [here](https://stackoverflow.com/help/how-to-answer). – Rahul Sharma May 20 '17 at 18:23

Force landscape mode in one ViewController using Swift

21 Answers21

Swift 4

Swift 3

iOS 16+: `requestGeometryUpdate(_:errorHandler:)` API

Linked

Related

Force landscape mode in one ViewController using Swift

21 Answers21

Swift 4

Swift 3

iOS 16+: requestGeometryUpdate(_:errorHandler:) API

Linked

Related

iOS 16+: `requestGeometryUpdate(_:errorHandler:)` API