Sebelum iOS 8, kami menggunakan kode di bawah ini dalam hubungannya dengan metode InterfaceOrientations yang didukung dan metode delegasi shouldAutoRotate untuk memaksa orientasi aplikasi ke orientasi tertentu. Saya menggunakan potongan kode di bawah ini untuk memutar aplikasi ke orientasi yang diinginkan. Pertama, saya mengubah orientasi bilah status. Dan kemudian hanya menampilkan dan segera menolak tampilan modal memutar tampilan ke orientasi yang diinginkan.

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

Tapi ini gagal di iOS 8. Juga, saya telah melihat beberapa jawaban di stack overflow di mana orang menyarankan agar kita selalu menghindari pendekatan ini dari iOS 8 dan seterusnya.

Untuk lebih spesifik, aplikasi saya adalah tipe aplikasi universal. Ada tiga pengontrol secara total.

1. Pengontrol Tampilan Pertama - Ini harus mendukung semua orientasi di iPad dan hanya potret (tombol home down) di iPhone.

2. Pengontrol Tampilan Kedua - Seharusnya hanya mendukung lansekap tepat di semua kondisi

3. Pengontrol Tampilan Ketiga - Seharusnya hanya mendukung lanskap tepat di semua kondisi

Kami menggunakan pengontrol navigasi untuk navigasi halaman. Dari pengontrol tampilan pertama, pada aksi klik tombol, kami mendorong yang kedua pada stack. Jadi, ketika pengontrol tampilan kedua tiba, terlepas dari orientasi perangkat, aplikasi hanya akan mengunci lansekap.

Di bawah ini adalah saya shouldAutorotatedan supportedInterfaceOrientationsmetode di controller tampilan kedua dan ketiga.

-(NSUInteger)supportedInterfaceOrientations{
    return UIInterfaceOrientationMaskLandscapeRight;
}

-(BOOL)shouldAutorotate {
    return NO;
}

Apakah ada solusi untuk ini atau cara yang lebih baik untuk mengunci view controller dalam orientasi tertentu untuk iOS 8. Tolong bantu !!

Untuk iOS 7 - 10:

Tujuan-C:

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

Swift 3:

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

Sebut saja di - viewDidAppear:pengontrol tampilan yang disajikan.

Rotasi orientasi sedikit lebih rumit jika Anda berada di dalam UINavigationControlleratau UITabBarController. Masalahnya adalah bahwa jika pengendali tampilan tertanam di salah satu pengendali ini, pengendali navigasi atau tab bar akan diutamakan dan membuat keputusan tentang autorotation dan orientasi yang didukung.

Saya menggunakan 2 ekstensi berikut pada UINavigationController dan UITabBarController sehingga melihat pengontrol yang tertanam di salah satu pengontrol ini bisa membuat keputusan.

Berikan View Controllers the Power!

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

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

Sekarang Anda dapat mengganti supportedInterfaceOrientationsmetode atau menimpa shouldAutoRotatedi pengontrol tampilan yang ingin dikunci jika tidak, Anda dapat mengabaikan penggantian di pengontrol tampilan lain yang ingin Anda warisi perilaku orientasi default yang ditentukan dalam daftar aplikasi Anda

Nonaktifkan Rotasi

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

Kunci ke Orientasi Tertentu

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

Secara teori ini harus bekerja untuk semua hierarki pengendali tampilan yang kompleks, tapi saya perhatikan ada masalah dengan UITabBarController. Untuk beberapa alasan ia ingin menggunakan nilai orientasi default. Lihat posting blog berikut jika Anda tertarik mempelajari cara mengatasi beberapa masalah:

Kunci Rotasi Layar

Inilah yang bekerja untuk saya:

https://developer.apple.com/library//ios/documentation/UIKit/Reference/UIViewController_Class/index.html#//apple_ref/occ/clm/UIViewController/attemptRotationToDeviceOrientation

Sebut saja di metode viewDidAppear: Anda.

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

    [UIViewController attemptRotationToDeviceOrientation];
}

Saya menemukan bahwa jika itu adalah pengontrol tampilan yang disajikan, Anda dapat menimpanya preferredInterfaceOrientationForPresentation

Cepat:

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

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

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

Cara ini cocok untuk saya di Swift 2 iOS 8.x:

PS (metode ini tidak perlu mengesampingkan fungsi orientasi seperti shouldautorotate pada setiap viewController, cukup satu metode di AppDelegate)

Periksa "memerlukan layar penuh" di info umum proyek Anda.

Jadi, di AppDelegate.swift buat variabel:

var enableAllOrientation = false

Jadi, letakkan juga func ini:

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

Jadi, di setiap kelas di proyek Anda, Anda dapat mengatur var ini di viewWillAppear:

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

Jika Anda perlu membuat pilihan berdasarkan jenis perangkat Anda dapat melakukan ini:

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

Pertama-tama - ini adalah ide yang buruk, secara umum, ada yang salah dengan arsitektur aplikasi Anda, tetapi sh..t happens, jika demikian, Anda dapat mencoba membuat sesuatu seperti di bawah ini:

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

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

Dan setiap kali Anda ingin mengubah orientasi lakukan sebagai:

OrientationController.forceLockOrientation(.landscapeRight)

Catatan: Terkadang, perangkat mungkin tidak diperbarui dari panggilan tersebut, jadi Anda mungkin perlu melakukan sebagai berikut

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

Itu saja

Ini harus bekerja dari iOS 6 ke atas, tetapi saya hanya mengujinya di iOS 8. Subkelas UINavigationControllerdan mengganti metode berikut:

- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation {
    return UIInterfaceOrientationLandscapeRight;
}

- (BOOL)shouldAutorotate {
    return NO;
}

Atau tanyakan pengontrol tampilan yang terlihat

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

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

dan terapkan metode di sana.

Ini adalah umpan balik ke komentar dalam jawaban Sid Shah , mengenai cara menonaktifkan animasi menggunakan:

[UIView setAnimationsEnabled:enabled];

Kode:

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

Jika Anda menggunakan navigationViewController Anda harus membuat superclass Anda sendiri untuk ini dan menimpa:

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

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

  return YES;
}

ini akan menonaktifkan rotasi di SecondViewController tetapi jika Anda mendorong SecondViewController Anda ketika perangkat Anda pada orientasi potret maka Anda SecondViewController akan muncul dalam mode potret.

Asumsikan bahwa Anda menggunakan storyboard. Anda harus membuat segmen manual ( Cara ) dan dalam metode "onClick" Anda:

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

Ini akan memaksa orientasi lanskap sebelum fitur superclass Anda menonaktifkan autorotate.

Pada Xcode 8metode dikonversi ke properti, jadi berikut ini berfungsi dengan Swift:

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

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

override public var shouldAutorotate: Bool {
    return true
}

Saya telah mencoba banyak solusi, tetapi yang berhasil adalah sebagai berikut:

Tidak perlu mengedit info.plistdi ios 8 dan 9.

- (BOOL) shouldAutorotate {
    return NO;
}   

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

Kemungkinan orientasi dari Dokumentasi Apple :

UIInterfaceOrientationUnknown

Orientasi perangkat tidak dapat ditentukan.

UIInterfaceOrientationPortrait

Perangkat dalam mode potret, dengan perangkat dipegang tegak dan tombol home di bagian bawah.

UIInterfaceOrientationPortraitUpsideDown

Perangkat dalam mode potret tetapi terbalik, dengan perangkat dipegang tegak dan tombol home di atas.

UIInterfaceOrientationLandscapeLeft

Perangkat dalam mode lansekap, dengan perangkat dipegang tegak dan tombol beranda di sisi kiri.

UIInterfaceOrientationLandscapeRight

Perangkat dalam mode lansekap, dengan perangkat dipegang tegak dan tombol beranda di sisi kanan.

Kombinasi jawaban Sids dan Koreys bekerja untuk saya.

Memperluas Pengendali Navigasi:

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

Kemudian nonaktifkan rotasi pada Tampilan tunggal

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

Dan berputar ke orientasi yang sesuai sebelum segue

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

Solusi teratas di atas:

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

tidak bekerja untuk saya ketika saya menyebutnya di viewDidAppear dari pengontrol tampilan yang disajikan. Namun itu berhasil ketika saya memanggilnya di preparForSegue di controller tampilan presentasi.

(Maaf, reputasi poin tidak cukup untuk mengomentari solusi itu, jadi saya harus menambahkannya seperti ini)

[iOS9 +] Jika ada yang menyeret ke sini karena tidak ada solusi di atas yang berfungsi, dan jika Anda menyajikan tampilan yang ingin Anda ubah orientasi dengan segue, Anda mungkin ingin memeriksanya.

Periksa jenis presentasi segue Anda. Milik saya 'atas konteks saat ini'. Ketika saya mengubahnya ke Layar Penuh, itu berhasil.

Terima kasih kepada @GabLeRoux, saya menemukan solusi ini.

• Perubahan ini hanya berfungsi jika dikombinasikan dengan solusi di atas.

Persyaratan saya adalah

1. mengunci semua tampilan dalam mode potret
2. gunakan AVPlayerViewControlleruntuk memutar video

Saat video diputar, jika berupa lanskap maka izinkan layar untuk memutar lanskap ke kanan dan kiri lanskap. Jika itu potret maka kunci tampilan dalam mode potret saja.

Pertama, tentukan supportedInterfaceOrientationsForWindowdiAppDelegate.swift

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

Kedua, di pengontrol tampilan utama Anda, tentukan fungsi berikut

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

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

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

Kemudian, Anda perlu subkelas 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
            }
        }
    }

Timpa ketiga fungsi ini di MyPlayerViewController.swift

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

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

Karena pengguna mungkin memutar lansekap perangkat ke kiri atau lansiran kanan, kita perlu mengatur rotasi otomatis menjadi true

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

Akhirnya, buat MyPlayerViewControllerinstance di pengontrol tampilan Anda dan atur nilai ukuran properti.

let playerViewController = MyPlayerViewController()

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

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

Inisiasi pemain Anda dengan benar videoUrl, lalu tetapkan pemain Anda ke playerViewController. Selamat coding!

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

Tampaknya masih ada beberapa perdebatan tentang cara terbaik untuk menyelesaikan tugas ini, jadi saya pikir saya akan berbagi pendekatan (bekerja) saya. Tambahkan kode berikut dalam UIViewControllerimplementasi Anda :

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

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

-(BOOL)shouldAutorotate
{
    return NO;
}

- (UIInterfaceOrientationMask)supportedInterfaceOrientations
{
    return UIInterfaceOrientationMaskLandscapeLeft;
}

Untuk contoh ini, Anda juga perlu mengatur orientasi perangkat yang diizinkan ke 'Landscape Left' di pengaturan proyek Anda (atau langsung masuk info.plist ). Ubah saja orientasi spesifik yang ingin Anda paksakan jika Anda menginginkan sesuatu selainLandscapeLeft.

Kuncinya bagi saya adalah attemptRotationToDeviceOrientationpanggilan masuk viewWillAppear- tanpa itu tampilan tidak akan berputar dengan baik tanpa memutar perangkat secara fisik.

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

Nonaktifkan Rotasi

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

Kunci ke Orientasi Tertentu

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

Saya mencoba beberapa solusi di sini dan yang penting untuk dipahami adalah pengontrol tampilan akar yang akan menentukan apakah akan diputar atau tidak.

Saya buat berikut tujuan-c proyek github.com/GabLeRoux/RotationLockInTabbedViewChild dengan contoh kerja dariTabbedViewController mana satu tampilan anak diperbolehkan berputar dan pandangan anak lainnya terkunci dalam potret.

Ini tidak sempurna tetapi berfungsi dan ide yang sama harus bekerja untuk jenis tampilan root lainnya seperti NavigationViewController. :)

Menurut solusi yang ditunjukkan oleh @ sid-sha Anda harus meletakkan semuanya dalam viewDidAppear:metode, jika tidak, Anda tidak akan didRotateFromInterfaceOrientation:dipecat, jadi sesuatu seperti:

- (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"];
    }
}

Solusi saya

Di AppDelegate:

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

XXViewController adalah ViewController yang ingin Anda dukung mode Lansekap.

Maka solusi Sunny Shah akan bekerja di Anda XXViewControllerpada versi iOS apa pun:

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

Ini adalah fungsi utilitas untuk menemukan ViewController paling atas.

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
    }

}

Gunakan ini untuk mengunci orientasi pengontrol tampilan, yang diuji pada iOS 9:

// Kunci orientasi ke kanan lansekap

-(UIInterfaceOrientationMask)supportedInterfaceOrientations {
    return UIInterfaceOrientationMaskLandscapeRight;
}

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

Saya memiliki masalah yang sama dan menghabiskan banyak waktu untuk itu. Jadi sekarang saya punya solusi. Pengaturan aplikasi saya hanya mendukung potret saja. Namun, beberapa layar ke dalam aplikasi saya perlu hanya lanskap. Saya memperbaikinya dengan memiliki variabel isShouldRotate at AppDelegate . Dan fungsi di AppDelegate :

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

Dan akhirnya ketika ViewControllerA membutuhkan kondisi lansekap. Lakukan saja: sebelum push / present ke ViewController, tetapkan isShouldRotate ke true . Jangan lupa ketika pop / abaikan bahwa assign controller isShouldRotate ke false di viewWillDisappear .

Bagi saya, VC tingkat atas diperlukan untuk mengimplementasikan orientasi yang ditimpa. Menggunakan VC di tumpukan tidak akan berpengaruh jika VC atas tidak menerapkan.

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

Hanya VC-Main yang didengarkan, pada dasarnya dalam pengujian saya.

Sepertinya bahkan kamu di sini begitu banyak jawaban tidak ada yang cukup untukku. Saya ingin memaksakan orientasi dan kemudian kembali kembali ke orientasi perangkat tetapi [UIViewController attemptRotationToDeviceOrientation];tidak berhasil. Yang juga rumit adalah saya menambahkan shouldAutorotate ke false berdasarkan beberapa jawaban dan tidak bisa mendapatkan efek yang diinginkan untuk memutar kembali dengan benar di semua skenario.

Jadi ini yang saya lakukan:

Sebelum mendorong controller dalam panggilan di init konstruktornya ini:

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

Jadi saya menyimpan orientasi perangkat terakhir dan mendaftar untuk acara perubahan orientasi. Acara perubahan orientasi sederhana:

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

Dan pada pandangan dissmising saya hanya memaksa kembali ke orientasi yang saya miliki sebagai userOreintation:

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

Dan ini juga harus ada di sana:

- (BOOL)shouldAutorotate {
    return true;
}

- (UIInterfaceOrientationMask)supportedInterfaceOrientations {
    return UIInterfaceOrientationMaskPortrait;
}

Dan juga pengendali navigasi harus mendelegasikan ke shouldAutorotate dan didukungInterfaceOrientations, tetapi kebanyakan orang sudah memiliki saya percaya.

PS: Maaf saya menggunakan beberapa ekstensi dan kelas dasar tetapi nama cukup berarti sehingga konsep dapat dimengerti, akan membuat lebih banyak ekstensi karena itu tidak terlalu cantik sekarang.