Trước iOS 8, chúng tôi đã sử dụng mã bên dưới kết hợp với các phương thức ủy nhiệm được hỗ trợInterfaceOrientations và ShouldAutoRotate để buộc định hướng ứng dụng theo bất kỳ hướng cụ thể nào. Tôi đã sử dụng đoạn mã dưới đây để lập trình xoay ứng dụng theo hướng mong muốn. Thứ nhất, tôi đang thay đổi hướng thanh trạng thái. Và sau đó chỉ cần trình bày và ngay lập tức loại bỏ một chế độ xem phương thức xoay chế độ xem theo hướng mong muốn.

[[UIApplication sharedApplication] setStatusBarOrientation:UIInterfaceOrientationLandscapeRight animated:YES];
UIViewController *c = [[UIViewController alloc]init];
[self presentViewController:vc animated:NO completion:nil];
[self dismissViewControllerAnimated:NO completion:nil];

Nhưng điều này không thành công trong iOS 8. Ngoài ra, tôi đã thấy một số câu trả lời trong stack stack, nơi mọi người đề nghị rằng chúng ta nên luôn luôn tránh cách tiếp cận này từ iOS 8 trở đi.

Cụ thể hơn, ứng dụng của tôi là một loại ứng dụng phổ quát. Có ba bộ điều khiển trong tổng số.

1. Bộ điều khiển Chế độ xem Đầu tiên - Nó sẽ hỗ trợ tất cả các định hướng trong iPad và chỉ chân dung (nút home trở xuống) trong iPhone.

2. Bộ điều khiển Chế độ xem Thứ hai - Nó chỉ hỗ trợ cảnh quan ngay trong mọi điều kiện

3. Bộ điều khiển Chế độ xem Thứ ba - Nó chỉ hỗ trợ cảnh quan ngay trong mọi điều kiện

Chúng tôi đang sử dụng bộ điều khiển điều hướng để điều hướng trang. Từ trình điều khiển chế độ xem đầu tiên, trên hành động nhấp vào nút, chúng tôi sẽ đẩy nút thứ hai lên ngăn xếp. Vì vậy, khi bộ điều khiển chế độ xem thứ hai xuất hiện, bất kể hướng của thiết bị, ứng dụng chỉ nên khóa theo chiều ngang.

Dưới đây là của tôi shouldAutorotatevà supportedInterfaceOrientationsphương thức trong bộ điều khiển xem thứ hai và thứ ba.

-(NSUInteger)supportedInterfaceOrientations{
    return UIInterfaceOrientationMaskLandscapeRight;
}

-(BOOL)shouldAutorotate {
    return NO;
}

Có giải pháp nào cho việc này hay bất kỳ cách nào tốt hơn để khóa bộ điều khiển xem theo hướng cụ thể cho iOS 8. Xin hãy giúp đỡ !!

Dành cho iOS 7 - 10:

Mục tiêu-C:

[[UIDevice currentDevice] setValue:@(UIInterfaceOrientationLandscapeLeft) forKey:@"orientation"];
[UINavigationController attemptRotationToDeviceOrientation];

Swift 3:

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

Chỉ cần gọi nó trong - viewDidAppear:trình điều khiển xem trình bày.

Xoay định hướng phức tạp hơn một chút nếu bạn ở trong UINavigationControllerhoặc UITabBarController. Vấn đề là nếu một bộ điều khiển khung nhìn được nhúng vào một trong các bộ điều khiển này thì bộ điều khiển thanh điều hướng hoặc thanh tab được ưu tiên và đưa ra các quyết định về tự động hóa và định hướng được hỗ trợ.

Tôi sử dụng 2 phần mở rộng sau đây trên UINavestionControll và UITabBarContoder để xem các bộ điều khiển được nhúng trong một trong các bộ điều khiển này có thể đưa ra quyết định.

Cung cấp cho bộ điều khiển View sức mạnh!

Swift 2.3

extension UINavigationController {
    public override func supportedInterfaceOrientations() -> Int {
        return visibleViewController.supportedInterfaceOrientations()
    }
    public override func shouldAutorotate() -> Bool {
        return visibleViewController.shouldAutorotate()
    }
}

extension UITabBarController {
    public override func supportedInterfaceOrientations() -> Int {
        if let selected = selectedViewController {
            return selected.supportedInterfaceOrientations()
        }
        return super.supportedInterfaceOrientations()
    }
    public override func shouldAutorotate() -> Bool {
        if let selected = selectedViewController {
            return selected.shouldAutorotate()
        }
        return super.shouldAutorotate()
    }
}

Swift 3

extension UINavigationController {
    open override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return visibleViewController?.supportedInterfaceOrientations ?? super.supportedInterfaceOrientations
    }

    open override var shouldAutorotate: Bool {
        return visibleViewController?.shouldAutorotate ?? super.shouldAutorotate
    }
}

extension UITabBarController {
    open override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        if let selected = selectedViewController {
            return selected.supportedInterfaceOrientations
        }
        return super.supportedInterfaceOrientations
    }

    open override var shouldAutorotate: Bool {
        if let selected = selectedViewController {
            return selected.shouldAutorotate
        }
        return super.shouldAutorotate
    }
}

Bây giờ bạn có thể ghi đè supportedInterfaceOrientationsphương thức hoặc bạn có thể ghi đè shouldAutoRotatetrong trình điều khiển chế độ xem mà bạn muốn khóa nếu không bạn có thể bỏ qua các phần ghi đè trong các trình điều khiển chế độ xem khác mà bạn muốn kế thừa hành vi định hướng mặc định được chỉ định trong phần mềm ứng dụng của bạn

Vô hiệu hóa Xoay

class ViewController: UIViewController {
    override func shouldAutorotate() -> Bool {
        return false
    }
}

Khóa để định hướng cụ thể

class ViewController: UIViewController {
    override func supportedInterfaceOrientations() -> Int {
        return Int(UIInterfaceOrientationMask.Landscape.rawValue)
    }
}

Về lý thuyết, nó sẽ hoạt động cho tất cả các hệ thống phân cấp của bộ điều khiển xem phức tạp, nhưng tôi đã nhận thấy một vấn đề với UITabBarContoder. Vì một số lý do, nó muốn sử dụng một giá trị định hướng mặc định. Xem bài đăng trên blog sau nếu bạn muốn tìm hiểu về cách khắc phục một số vấn đề:

Xoay màn hình khóa

Đây là những gì làm việc cho tôi:

https://developer.apple.com/l Library//ios / document / UIKit / Reference / UIViewControll_Class / index.html # / //pleplef / occ / clm / UIViewContoder / pateemRotationToDeviceOrientation

Gọi nó trong phương thức viewDidAppear: của bạn.

- (void) viewDidAppear:(BOOL)animated
{
    [super viewDidAppear:animated];

    [UIViewController attemptRotationToDeviceOrientation];
}

Tôi thấy rằng nếu đó là một trình điều khiển xem được trình bày, bạn có thể ghi đè preferredInterfaceOrientationForPresentation

Nhanh:

override func supportedInterfaceOrientations() -> Int {
  return Int(UIInterfaceOrientationMask.Landscape.rawValue)
}

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

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

Cách này hiệu quả với tôi trong Swift 2 iOS 8.x:

PS (phương thức này không yêu cầu ghi đè các hàm định hướng như Shouldautorotate trên mỗi viewContoder, chỉ một phương thức trên AppDelegate)

Kiểm tra "yêu cầu toàn màn hình" trong thông tin chung của bạn.

Vì vậy, trên AppDelegate.swift hãy tạo một biến:

var enableAllOrientation = false

Vì vậy, cũng đặt func này:

func application(application: UIApplication, supportedInterfaceOrientationsForWindow window: UIWindow?) -> UIInterfaceOrientationMask {
        if (enableAllOrientation == true){
            return UIInterfaceOrientationMask.All
        }
        return UIInterfaceOrientationMask.Portrait
}

Vì vậy, trong mỗi lớp trong dự án của bạn, bạn có thể đặt var này trong viewWillAppear:

override func viewWillAppear(animated: Bool)
{
        super.viewWillAppear(animated)
        let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
        appDelegate.enableAllOrientation = true
}

Nếu bạn cần đưa ra lựa chọn dựa trên loại thiết bị, bạn có thể thực hiện việc này:

override func viewWillAppear(animated: Bool)
    {
        super.viewWillAppear(animated)
        let appDelegate = UIApplication.sharedApplication().delegate as! AppDelegate
        switch UIDevice.currentDevice().userInterfaceIdiom {
        case .Phone:
        // It's an iPhone
           print(" - Only portrait mode to iPhone")
           appDelegate.enableAllOrientation = false
        case .Pad:
        // It's an iPad
           print(" - All orientation mode enabled on iPad")
           appDelegate.enableAllOrientation = true
        case .Unspecified:
        // Uh, oh! What could it be?
           appDelegate.enableAllOrientation = false
        }
    }

Trước hết - đây là một ý tưởng tồi, nói chung, có điều gì đó không ổn với kiến ​​trúc ứng dụng của bạn, nhưng sh..t happens, nếu vậy, bạn có thể thử thực hiện một cái gì đó như dưới đây:

final class OrientationController {

    static private (set) var allowedOrientation:UIInterfaceOrientationMask = [.all]

    // MARK: - Public

    class func lockOrientation(_ orientationIdiom: UIInterfaceOrientationMask) {
        OrientationController.allowedOrientation = [orientationIdiom]
    }

    class func forceLockOrientation(_ orientation: UIInterfaceOrientation) {
        var mask:UIInterfaceOrientationMask = []
        switch orientation {
            case .unknown:
                mask = [.all]
            case .portrait:
                mask = [.portrait]
            case .portraitUpsideDown:
                mask = [.portraitUpsideDown]
            case .landscapeLeft:
                mask = [.landscapeLeft]
            case .landscapeRight:
                mask = [.landscapeRight]
        }

        OrientationController.lockOrientation(mask)

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

Hơn, trong AppDelegate

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    // do stuff
    OrientationController.lockOrientation(.portrait)
    return true
}

// MARK: - Orientation

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

Và bất cứ khi nào bạn muốn thay đổi định hướng, hãy làm như sau:

OrientationController.forceLockOrientation(.landscapeRight)

Lưu ý: Đôi khi, thiết bị có thể không cập nhật từ cuộc gọi như vậy, vì vậy bạn có thể cần phải làm như sau

OrientationController.forceLockOrientation(.portrait)
OrientationController.forceLockOrientation(.landscapeRight)

Đó là tất cả

Điều này sẽ hoạt động từ iOS 6 trở lên, nhưng tôi chỉ thử nghiệm nó trên iOS 8. Lớp con UINavigationControllervà ghi đè các phương thức sau:

- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation {
    return UIInterfaceOrientationLandscapeRight;
}

- (BOOL)shouldAutorotate {
    return NO;
}

Hoặc hỏi bộ điều khiển xem có thể nhìn thấy

- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation {
    return self.visibleViewController.preferredInterfaceOrientationForPresentation;
}

- (BOOL)shouldAutorotate {
    return self.visibleViewController.shouldAutorotate;
}

và thực hiện các phương pháp đó.

Đây là phản hồi cho các bình luận trong câu trả lời của Sid Shah , liên quan đến cách vô hiệu hóa hoạt hình bằng cách sử dụng:

[UIView setAnimationsEnabled:enabled];

Mã số:

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:NO];
    [UIView setAnimationsEnabled:NO];

    // Stackoverflow #26357162 to force orientation
    NSNumber *value = [NSNumber numberWithInt:UIInterfaceOrientationLandscapeRight];
    [[UIDevice currentDevice] setValue:value forKey:@"orientation"];
}

- (void)viewDidAppear:(BOOL)animated {
    [super viewDidAppear:NO];
    [UIView setAnimationsEnabled:YES];
}

Nếu bạn đang sử dụng navigationViewContaptor, bạn nên tạo siêu lớp của riêng mình cho việc này và ghi đè:

- (BOOL)shouldAutorotate {
  id currentViewController = self.topViewController;

  if ([currentViewController isKindOfClass:[SecondViewController class]])
    return NO;

  return YES;
}

điều này sẽ vô hiệu hóa xoay vòng trong SecondViewContaptor nhưng nếu bạn đẩy SecondViewContaptor của mình khi thiết bị của bạn ở hướng dọc thì SecondViewControll của bạn sẽ xuất hiện ở chế độ .

Giả sử rằng bạn đang sử dụng bảng phân cảnh. Bạn phải tạo segue thủ công ( Cách thực hiện ) và trong phương thức "onClick" của bạn:

- (IBAction)onPlayButtonClicked:(UIBarButtonItem *)sender {
  NSNumber *value = [NSNumber numberWithInt:UIInterfaceOrientationLandscapeLeft];
  [[UIDevice currentDevice] setValue:value forKey:@"orientation"];
  [self performSegueWithIdentifier:@"PushPlayerViewController" sender:self];
}

Điều này sẽ buộc định hướng ngang trước khi siêu lớp của bạn vô hiệu hóa tính năng autorotate.

Trên Xcode 8các phương thức được chuyển đổi thành thuộc tính, do đó, các công việc sau đây với Swift:

override public var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return UIInterfaceOrientationMask.portrait
}

override public var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
    return UIInterfaceOrientation.portrait
}

override public var shouldAutorotate: Bool {
    return true
}

Tôi đã thử nhiều giải pháp, nhưng giải pháp hiệu quả là:

Không cần chỉnh sửa info.plisttrong ios 8 và 9.

- (BOOL) shouldAutorotate {
    return NO;
}   

- (UIInterfaceOrientationMask)supportedInterfaceOrientations {
    return (UIInterfaceOrientationPortrait | UIInterfaceOrientationPortraitUpsideDown);
}

Định hướng có thể từ Tài liệu Apple :

UIInterfaceOrientationUn Unknown

Định hướng của thiết bị không thể được xác định.

Cổng UIInterfaceOrientationPort

Thiết bị ở chế độ dọc, với thiết bị được giữ thẳng đứng và nút home ở phía dưới.

UIInterfaceOrientationPortaboutUpsideDown

Thiết bị ở chế độ dọc nhưng lộn ngược, với thiết bị được giữ thẳng đứng và nút home ở trên cùng.

UIInterfaceOrientationLandscapeLeft

Thiết bị ở chế độ nằm ngang, với thiết bị được giữ thẳng đứng và nút home ở bên trái.

UIInterfaceOrientationLandscapeRight

Thiết bị ở chế độ nằm ngang, với thiết bị được giữ thẳng đứng và nút home ở bên phải.

Sự kết hợp giữa câu trả lời của Sids và Koreys có hiệu quả với tôi.

Mở rộng Bộ điều khiển Điều hướng:

extension UINavigationController {
    public override func shouldAutorotate() -> Bool {
        return visibleViewController.shouldAutorotate()
    }
}

Sau đó vô hiệu hóa xoay trên Chế độ xem đơn

class ViewController: UIViewController {
    override func shouldAutorotate() -> Bool {
        return false
    }
}

Và xoay theo hướng thích hợp trước khi phân biệt

override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
    if (segue.identifier == "SomeSegue")
    {
        let value = UIInterfaceOrientation.Portrait.rawValue;
        UIDevice.currentDevice().setValue(value, forKey: "orientation")
    }
}

Giải pháp hàng đầu ở trên:

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

đã không làm việc cho tôi khi tôi gọi nó trong viewDidAppear của trình điều khiển khung nhìn được trình bày. Tuy nhiên, nó đã hoạt động khi tôi gọi nó trong PrepForSegue trong trình điều khiển khung nhìn trình bày.

(Xin lỗi, không đủ điểm danh tiếng để nhận xét về giải pháp đó, vì vậy tôi đã phải thêm nó như thế này)

[iOS9 +] Nếu bất kỳ ai kéo xuống đây vì không có giải pháp nào ở trên hoạt động và nếu bạn trình bày chế độ xem bạn muốn thay đổi hướng theo segue, bạn có thể muốn kiểm tra điều này.

Kiểm tra loại trình bày của segue của bạn. Của tôi là "trong bối cảnh hiện tại". Khi tôi thay đổi nó thành Toàn màn hình, nó hoạt động.

Nhờ @GabLeRoux, tôi đã tìm thấy giải pháp này.

• Thay đổi này chỉ hoạt động khi kết hợp với các giải pháp ở trên.

Yêu cầu của tôi là

1. khóa tất cả các chế độ xem ở chế độ dọc
2. sử dụng AVPlayerViewControllerđể phát video

Khi video đang phát, nếu đó là phong cảnh thì cho phép màn hình xoay ngang phải và ngang trái. Nếu đó là chân dung thì chỉ khóa chế độ xem ở chế độ dọc.

Đầu tiên, xác định supportedInterfaceOrientationsForWindowtrongAppDelegate.swift

var portrait = true
func application(application: UIApplication, supportedInterfaceOrientationsForWindow window: UIWindow?) -> UIInterfaceOrientationMask {
    if portrait {
        return .Portrait
    } else {
        return .Landscape
    }
}

Thứ hai, trong trình điều khiển khung nhìn chính của bạn, xác định các chức năng sau

override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
    print("\(#function)")
    return .Portrait
}

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

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

Sau đó, bạn cần phải phân lớp AVPlayerViewController

class MyPlayerViewController: AVPlayerViewController {

    var size: CGSize?

    var supportedOrientationMask: UIInterfaceOrientationMask?
    var preferredOrientation: UIInterfaceOrientation?

    override func viewDidLoad() {
        super.viewDidLoad()

        if let size = size {
            if size.width > size.height {
                self.supportedOrientationMask =[.LandscapeLeft,.LandscapeRight]
                self.preferredOrientation =.LandscapeRight
            } else {
                self.supportedOrientationMask =.Portrait
                self.preferredOrientation =.Portrait
            }
        }
    }

Ghi đè ba chức năng này trong MyPlayerViewController.swift

override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
    return self.supportedOrientationMask!
}

override func preferredInterfaceOrientationForPresentation() -> UIInterfaceOrientation {
    return self.preferredOrientation!
}

Vì người dùng có thể xoay ngang thiết bị sang trái hoặc ngang phải, nên chúng tôi cần đặt tự động xoay thành đúng

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

Cuối cùng, tạo MyPlayerViewControllercá thể trong trình điều khiển khung nhìn của bạn và đặt giá trị kích thước thuộc tính.

let playerViewController = MyPlayerViewController()

// Get the thumbnail  
let thumbnail = MyAlbumFileManager.sharedManager().getThumbnailFromMyVideoMedia(......)

let size = thumbnail?.size
playerViewController.size = size

Bắt đầu trình phát của bạn với đúng videoUrl, sau đó chỉ định trình phát của bạn playerViewController. Chúc mừng mã hóa!

- (void)viewDidAppear:(BOOL)animated
{
    [super viewDidAppear:animated];
    [UIViewController attemptRotationToDeviceOrientation];
}

Dường như vẫn còn một số tranh luận về cách tốt nhất để hoàn thành nhiệm vụ này, vì vậy tôi nghĩ rằng tôi muốn chia sẻ phương pháp (làm việc) của mình. Thêm mã sau đây trong UIViewControllertriển khai của bạn :

- (void) viewWillAppear:(BOOL)animated
{
    [UIViewController attemptRotationToDeviceOrientation];
}

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation
{
    return (toInterfaceOrientation == UIInterfaceOrientationLandscapeLeft);
}

-(BOOL)shouldAutorotate
{
    return NO;
}

- (UIInterfaceOrientationMask)supportedInterfaceOrientations
{
    return UIInterfaceOrientationMaskLandscapeLeft;
}

Trong ví dụ này, bạn cũng sẽ cần đặt các hướng thiết bị được phép của mình thành 'Cảnh trái' trong cài đặt dự án của bạn (hoặc trực tiếp trong info.plist). Chỉ cần thay đổi hướng cụ thể mà bạn muốn ép buộc nếu bạn muốn một cái gì đó ngoàiLandscapeLeft.

Chìa khóa cho tôi là attemptRotationToDeviceOrientationcuộc gọi trong viewWillAppear- không có chế độ xem sẽ không xoay đúng cách mà không xoay thiết bị.

Dựa theo câu trả lời của Korey Hinton

Swift 2.2:

extension UINavigationController {
    public override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
        return visibleViewController!.supportedInterfaceOrientations()
    }
    public override func shouldAutorotate() -> Bool {
        return visibleViewController!.shouldAutorotate()
    }
}


extension UITabBarController {
    public override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
        if let selected = selectedViewController {
            return selected.supportedInterfaceOrientations()
        }
        return super.supportedInterfaceOrientations()
    }
    public override func shouldAutorotate() -> Bool {
        if let selected = selectedViewController {
            return selected.shouldAutorotate()
        }
        return super.shouldAutorotate()
    }
}

Vô hiệu hóa Xoay

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

Khóa để định hướng cụ thể

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

Tôi đã thử một vài giải pháp ở đây và điều quan trọng cần hiểu là đó là bộ điều khiển xem gốc sẽ xác định xem nó có xoay hay không.

Tôi đã tạo dự án object -c sau github.com/GabLeRoux/RotationLockInTabbedViewChild với một ví dụ hoạt động của mộtTabbedViewController nơi một chế độ xem con được phép xoay và chế độ xem con khác bị khóa trong chế độ dọc.

Nó không hoàn hảo nhưng nó hoạt động và cùng một ý tưởng sẽ hoạt động cho các loại quan điểm gốc khác như NavigationViewController. :)

Theo giải pháp được chỉ ra bởi @ sid-sha, bạn phải đặt mọi thứ vào viewDidAppear:phương thức, nếu không bạn sẽ không didRotateFromInterfaceOrientation:bị sa thải, vì vậy đại loại như:

- (void)viewDidAppear:(BOOL)animated {
    [super viewDidAppear:animated];
    UIInterfaceOrientation interfaceOrientation = [[UIApplication sharedApplication] statusBarOrientation];
    if (interfaceOrientation == UIInterfaceOrientationLandscapeLeft ||
        interfaceOrientation == UIInterfaceOrientationLandscapeRight) {
        NSNumber *value = [NSNumber numberWithInt:interfaceOrientation];
        [[UIDevice currentDevice] setValue:value forKey:@"orientation"];
    }
}

Giải pháp của tôi

Trong AppDelegate:

func application(application: UIApplication, supportedInterfaceOrientationsForWindow window: UIWindow?) -> UIInterfaceOrientationMask {
    if let topController = UIViewController.topMostViewController() {
        if topController is XXViewController {
            return [.Portrait, .LandscapeLeft]
        }
    }
    return [.Portrait]
}

XXViewController là ViewContoder mà bạn muốn hỗ trợ chế độ Cảnh.

Sau đó , giải pháp của Sunny Shah sẽ hoạt động trong XXViewControllerbất kỳ phiên bản iOS nào của bạn :

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

Đây là chức năng tiện ích để tìm ViewContoder hàng đầu.

extension UIViewController {

    /// Returns the current application's top most view controller.
    public class func topMostViewController() -> UIViewController? {
        let rootViewController = UIApplication.sharedApplication().windows.first?.rootViewController
        return self.topMostViewControllerOfViewController(rootViewController)
    }



    /// Returns the top most view controller from given view controller's stack.
    class func topMostViewControllerOfViewController(viewController: UIViewController?) -> UIViewController? {
        // UITabBarController
        if let tabBarController = viewController as? UITabBarController,
           let selectedViewController = tabBarController.selectedViewController {
            return self.topMostViewControllerOfViewController(selectedViewController)
        }

        // UINavigationController
        if let navigationController = viewController as? UINavigationController,
           let visibleViewController = navigationController.visibleViewController {
            return self.topMostViewControllerOfViewController(visibleViewController)
        }

        // presented view controller
        if let presentedViewController = viewController?.presentedViewController {
            return self.topMostViewControllerOfViewController(presentedViewController)
        }

        // child view controller
        for subview in viewController?.view?.subviews ?? [] {
            if let childViewController = subview.nextResponder() as? UIViewController {
                return self.topMostViewControllerOfViewController(childViewController)
            }
        }

        return viewController
    }

}

Sử dụng công cụ này để khóa hướng điều khiển xem, được thử nghiệm trên iOS 9:

// Khóa hướng sang ngang phải

-(UIInterfaceOrientationMask)supportedInterfaceOrientations {
    return UIInterfaceOrientationMaskLandscapeRight;
}

-(NSUInteger)navigationControllerSupportedInterfaceOrientations:(UINavigationController *)navigationController {
    return UIInterfaceOrientationMaskLandscapeRight;
}

Tôi có cùng một vấn đề và lãng phí rất nhiều thời gian cho nó. Vì vậy, bây giờ tôi có giải pháp của tôi. Cài đặt ứng dụng của tôi chỉ hỗ trợ chân dung. Tuy nhiên, một số màn hình vào ứng dụng của tôi chỉ cần có phong cảnh. Tôi sửa nó bằng một biến isShouldRotate tại AppDelegate . Và chức năng tại AppDelegate :

func application(application: UIApplication, supportedInterfaceOrientationsForWindow window: UIWindow?) -> Int {
    if isShouldRotate == true {
        return Int(UIInterfaceOrientationMask.Landscape.rawValue)
    }
    return Int(UIInterfaceOrientationMask.Portrait.rawValue)
}

Và cuối cùng khi một ViewContoderA cần trạng thái ngang. Chỉ cần làm điều đó: trước khi đẩy / trình bày cho ViewControllA gán isShouldRotate thành true . Đừng quên khi pop / bỏ qua mà trình điều khiển gán isShouldRotate thành false tại viewWillDisappear .

Đối với tôi, VC cấp cao nhất cần thiết để thực hiện ghi đè định hướng. Sử dụng VC xuống ngăn xếp sẽ không có hiệu lực nếu VC hàng đầu không thực hiện.

VC-main
    |
    -> VC 2
        |
        -> VC 3

Chỉ có VC-Main được lắng nghe, về cơ bản trong thử nghiệm của tôi.

Có vẻ như ngay cả bạn ở đây là rất nhiều câu trả lời không ai là đủ cho tôi. Tôi muốn buộc định hướng và sau đó quay trở lại định hướng thiết bị nhưng [UIViewController attemptRotationToDeviceOrientation];không hoạt động. Điều cũng làm mọi thứ phức tạp là tôi đã thêm nênAutorotate thành false dựa trên một số câu trả lời và không thể có được các hiệu ứng mong muốn để quay trở lại chính xác trong tất cả các tình huống.

Vì vậy, đây là những gì tôi đã làm:

Trước khi đẩy bộ điều khiển trong cuộc gọi trong hàm khởi tạo init của mình, điều này:

_userOrientation = UIDevice.currentDevice.orientation;
[UIDevice.currentDevice setValue:@(UIInterfaceOrientationPortrait) forKey:@"orientation"];
[self addNotificationCenterObserver:@selector(rotated:)
                               name:UIDeviceOrientationDidChangeNotification];

Vì vậy, tôi lưu định hướng thiết bị cuối cùng và đăng ký cho sự kiện thay đổi định hướng. Sự kiện thay đổi định hướng rất đơn giản:

- (void)rotated:(NSNotification*)notification {
    _userOrientation = UIDevice.currentDevice.orientation;
}

Và trên chế độ xem, tôi chỉ quay trở lại bất kỳ định hướng nào tôi có với tư cách là người dùng:

- (void)onViewDismissing {
    super.onViewDismissing;
    [UIDevice.currentDevice setValue:@(_userOrientation) forKey:@"orientation"];
    [UIViewController attemptRotationToDeviceOrientation];
}

Và điều này cũng phải có ở đó:

- (BOOL)shouldAutorotate {
    return true;
}

- (UIInterfaceOrientationMask)supportedInterfaceOrientations {
    return UIInterfaceOrientationMaskPortrait;
}

Và bộ điều khiển điều hướng cũng phải ủy quyền cho ShouldAotorotate và hỗ trợInterfaceOrientations, nhưng hầu hết mọi người đã tin tôi.

PS: Xin lỗi, tôi sử dụng một số tiện ích mở rộng và các lớp cơ sở nhưng tên khá có ý nghĩa nên khái niệm có thể hiểu được, sẽ tạo ra nhiều tiện ích mở rộng hơn vì hiện tại nó không quá đẹp.