Як зафіксувати орієнтацію одного контролера перегляду в портретному режимі лише в режимі Swift

Оскільки мій додаток отримав підтримку для всіх орієнтацій. Я хотів би заблокувати лише портретний режим для певного UIViewController.

наприклад, припустимо, що це була програма з вкладками, і коли режим входу в систему відображається модально, я хочу лише, щоб режим входу в режим портрета був незалежно від того, як користувач обертає пристрій або як буде поточна орієнтація пристрою

Речі можуть стати досить сумбурними, коли у вас складна ієрархія перегляду, наприклад, наявність декількох контролерів навігації та / або контролерів перегляду вкладки.

Ця реалізація встановлює на індивідуальних контролерах подання можливість встановлювати, коли вони хочуть зафіксувати орієнтації, замість того, щоб покладатися на Делегат програми, щоб знаходити їх шляхом ітерації через підзагляди.

Стрімкий 3, 4, 5

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

У якомусь іншому глобальному класі або допоміжному класі я створив 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()
    }

}

Потім у бажаному ViewController ви хочете зафіксувати орієнтацію:

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

Якщо iPad або Universal App

Переконайтеся, що прапорець "Потрібен повноекранний режим" встановлений у Налаштування цілі -> Загальні -> Інформація про розгортання. supportedInterfaceOrientationsForделегат не буде викликаний, якщо це не позначено.

Стрімкий 4

AppDelegate

var orientationLock = UIInterfaceOrientationMask.all

func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
    return self.orientationLock
}
struct AppUtility {
    static func lockOrientation(_ orientation: UIInterfaceOrientationMask) {
        if let delegate = UIApplication.shared.delegate as? AppDelegate {
            delegate.orientationLock = orientation
        }
    }

    static func lockOrientation(_ orientation: UIInterfaceOrientationMask, andRotateTo rotateOrientation:UIInterfaceOrientation) {
        self.lockOrientation(orientation)
        UIDevice.current.setValue(rotateOrientation.rawValue, forKey: "orientation")
    }
}

Ваш ViewController Додати наступний рядок, якщо вам потрібна лише книжкова орієнтація. Ви повинні застосувати це до всіх ViewController, щоб відобразити портретний режим.

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

і це зробить орієнтацію екрана для інших Viewcontroller відповідно до фізичної орієнтації пристрою.

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

    }

Свіфт 3 і 4

Встановіть supportedInterfaceOrientationsвластивість конкретних UIViewControllers таким чином:

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

    //...
}

ОНОВЛЕННЯ

Це рішення працює тільки тоді , коли ваш viewControllerбуде НЕ вбудований в UINavigationController, оскільки орієнтація успадковується від батьківського ViewController.
У цьому випадку ви можете створити підклас UINavigationViewControllerта встановити для нього ці властивості.

Додайте цей код, щоб змусити портрет і заблокувати його:

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
}

У вашому AppDelegate - встановіть supportedInterfaceOrientationsForWindow на будь-які орієнтації, які ви хочете, щоб підтримувала вся програма:

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

Це загальне рішення для вашої проблеми та інших, пов’язаних з нею.

1. Створіть допоміжний клас UIHelper і застосуйте наступні методи:

    /**This method returns top view controller in application  */
    class func topViewController() -> UIViewController?
    {
        let helper = UIHelper()
        return helper.topViewControllerWithRootViewController(rootViewController: UIApplication.shared.keyWindow?.rootViewController)
    }

    /**This is a recursive method to select the top View Controller in a app, either with TabBarController or not */
    private func topViewControllerWithRootViewController(rootViewController:UIViewController?) -> UIViewController?
    {
        if(rootViewController != nil)
        {
            // UITabBarController
            if let tabBarController = rootViewController as? UITabBarController,
                let selectedViewController = tabBarController.selectedViewController {
                return self.topViewControllerWithRootViewController(rootViewController: selectedViewController)
            }

            // UINavigationController
            if let navigationController = rootViewController as? UINavigationController ,let visibleViewController = navigationController.visibleViewController {
                return self.topViewControllerWithRootViewController(rootViewController: visibleViewController)
            }

            if ((rootViewController!.presentedViewController) != nil) {
                let presentedViewController = rootViewController!.presentedViewController;
                return self.topViewControllerWithRootViewController(rootViewController: presentedViewController!);
            }else
            {
                return rootViewController
            }
        }

        return nil
    }

2. Створіть протокол з вашим бажанням поведінки, для вашого конкретного випадку буде портрет.

протокол орієнтаціїIsOnlyPor Portrait {}

Примітка: Якщо хочете, додайте його у верхній частині класу UIHelper.

3. Розширте свій контролер перегляду

У вашому випадку:

class Any_ViewController: UIViewController,orientationIsOnlyPortrait {

   ....

}

4. У класі делегатів програми додайте цей метод:

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

Заключні примітки:

• Якщо ви знаєте, що більше класів перебуває в портретному режимі, просто розширіть цей протокол.
• Якщо вам потрібна поведінка інших користувачів від контролерів перегляду, створіть інші протоколи та дотримуйтесь тієї ж структури.
• Цей приклад вирішує проблему зі зміною орієнтації після контролерів push view

У цій темі купа чудових відповідей, але жодна не відповідає моїм потребам. У мене є додаток із вкладками з контролерами навігації на кожній вкладці, і один вигляд потрібно було обертати, а інші потрібно було заблокувати в портретному режимі. Навігаційний контролер з певних причин не змінює належним чином розмір своїх підпоглядів. Знайшов рішення (у Swift 3), поєднавши з цією відповіддю, і проблеми з макетом зникли. Створіть структуру, як запропонував @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")
    }
} 

Потім підклас 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
    }
}

Не забудьте змінити клас TabBarController у розкадровці на нещодавно створений підклас.

Для нової версії Swift спробуйте це

override var shouldAutorotate: Bool {
    return false
}

override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return UIInterfaceOrientationMask.portrait
}

override var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
    return UIInterfaceOrientation.portrait
}

Ось простий спосіб, який працює для мене з Swift 4.2 (iOS 12.2), помістіть це в, UIViewControllerдля якого ви хочете відключити shouldAutorotate:

override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return .portrait
}

.portraitЧастина розповідає , в якій орієнтація (s) , щоб залишитися, ви можете змінити це , як вам подобається. Варіанти: .portrait, .all, .allButUpsideDown, .landscape, .landscapeLeft, .landscapeRight, .portraitUpsideDown.

Щоб встановити альбомну орієнтацію для всього перегляду програми та дозволити лише один перегляд для всіх орієнтацій (щоб мати можливість додати рулон камери, наприклад):

У AppDelegate.swift:

var adaptOrientation = false

В: didFinishLaunchingWithOptions

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

В іншому місці в AppDelegate.swift:

func application(application: UIApplication, supportedInterfaceOrientationsForWindow window: UIWindow?) -> Int {
    return checkOrientation(self.window?.rootViewController)
}

func checkOrientation(viewController:UIViewController?)-> Int{
    if (adaptOrientation == false){
        return Int(UIInterfaceOrientationMask.Landscape.rawValue)
    }else {
        return Int(UIInterfaceOrientationMask.All.rawValue)
    }
}

func adaptOrientationAction(notification: NSNotification){
    if adaptOrientation == false {
        adaptOrientation = true
    }else {
        adaptOrientation = false
    }
}

Тоді, у поданні, яке відповідає тому, кого ви хочете мати, щоб мати всі орієнтації:

override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject!) {
    if (segue.identifier == "YOURSEGUE") {
        NSNotificationCenter.defaultCenter().postNotificationName("adaptOrientationAction", object: nil)
    }
}

override func viewWillAppear(animated: Bool) {
    if adaptOrientation == true {
        NSNotificationCenter.defaultCenter().postNotificationName("adaptOrientationAction", object: nil)
    }
}

Останнє - позначити орієнтацію пристрою: - Портрет - Пейзаж ліворуч - Пейзаж праворуч

Створити нове розширення за допомогою

import UIKit

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

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

bmjohns -> Ти мій рятівник життя. Це єдине робоче рішення (із структурою AppUtility)

Я створив цей клас:

class Helper{
    struct AppUtility {

        static func lockOrientation(_ orientation: UIInterfaceOrientationMask) {

            if let delegate = UIApplication.shared.delegate as? AppDelegate {
                delegate.orientationLock = orientation
            }
        }

        /// OPTIONAL Added method to adjust lock and rotate to the desired orientation
        static func lockOrientation(_ orientation: UIInterfaceOrientationMask, andRotateTo rotateOrientation:UIInterfaceOrientation) {

            self.lockOrientation(orientation)

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

    }
}

і слідував вашим вказівкам, і все ідеально працює для Swift 3 -> xcode версії 8.2.1

Починаючи з iOS 10 і 11, iPad підтримує перегляд слайдів та розділений перегляд. Щоб увімкнути програму в режимі Slide Over та Split View, Requires full screen потрібно зняти прапорець. Це означає, що прийняту відповідь не можна використовувати, якщо додаток хоче підтримувати Slide Over та Split View. Дивіться більше з розділу Прийняття поліпшень багатозадачності Apple на iPad тут .

У мене є рішення, яке дозволяє (1) зняти прапорець Requires full screen, (2) реалізувати лише одну функцію appDelegate(особливо якщо ви не хочете / не можете змінити цільові контролери подання) та (3) уникати рекурсивних викликів. Не потрібно ні допоміжного класу, ні розширень.

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

Редагувати

@bmjohns зазначив, що ця функція не викликається на iPad. Я перевірив і так його не викликали. Отже, я трохи більше тестував і з’ясував кілька фактів:

1. Я зняв прапорець, Requires full screenтому що хочу ввімкнути Slide Over і Slide View на iPad. Це вимагає додаток , щоб підтримати всі 4 орієнтації для IPad, в Info.plist: Supported interface orientations (iPad).

Мій додаток працює так само, як і Facebook: на iPhone, більшу частину часу він заблокований для портрета. Під час перегляду зображення на весь екран дозволяє користувачам обертати альбомну орієнтацію для кращого перегляду. На iPad користувачі можуть повертати в будь-яку орієнтацію в будь-яких контролерах перегляду. Отже, програма виглядає гарно, коли iPad стоїть на Smart Cover (зліва).

2. Щоб зателефонувати iPad application(_:supportedInterfaceOrientationsFor), у Info.plist зберігайте лише портрети для iPad. Додаток втратить можливість Slide Over + Split View. Але ви можете заблокувати або розблокувати орієнтацію для будь-якого контролера перегляду, лише в одному місці, і не потрібно змінювати клас ViewController.

3. Нарешті, ця функція викликається у життєвому циклі контролера перегляду, коли вигляд відображається / видаляється. Якщо додатку потрібно заблокувати / розблокувати / змінити орієнтацію в інший час, це може не спрацювати

Фактичне тестоване рішення для цього. У моєму прикладі мені потрібно, щоб вся моя програма мала бути в портретному режимі, але орієнтація лише на одному екрані повинна бути в альбомному режимі.

Код в AppDelegate, як описано вище.

var orientationLock = UIInterfaceOrientationMask.all

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

static func lockOrientation(_ orientation: UIInterfaceOrientationMask) {
    if let delegate = UIApplication.shared.delegate as? AppDelegate {
        delegate.orientationLock = orientation
    }
}
static func lockOrientation(_ orientation: UIInterfaceOrientationMask, andRotateTo rotateOrientation:UIInterfaceOrientation) {
self.lockOrientation(orientation)     
UIDevice.current.setValue(rotateOrientation.rawValue, forKey: "orientation")
}  
}

Потім запишіть цей код перед тим, як буде представлений / натиснутий контролер подання орієнтації в альбомному режимі.

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

Потім запишіть цей код у фактичному контролері перегляду (для альбомного перегляду)

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

Я трохи експериментував, і мені вдалося знайти чисте рішення цієї проблеми. Підхід заснований на тегуванні подання за допомогою тегу view->

У цільовому ViewController просто призначте тег кореневому поданню, як у наступному прикладі коду:

class MyViewController: BaseViewController {

  // declare unique view tag identifier
  static let ViewTag = 2105981;

  override func viewDidLoad()
  {
    super.viewDidLoad();
    // assign the value to the current root view
    self.view.tag = MyViewController.ViewTag;
  }

І нарешті, в AppDelegate.swift перевірте, чи на даний момент відображається подання, яке ми позначили тегами:

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

Цей підхід був перевірений на моєму тренажері, і, здається, він чудово працює.

Примітка: позначений вигляд також буде знайдений, якщо поточний MVC перекритий деяким дочірнім ViewController у стеку навігації.

Завдяки відповіді @ bmjohn вище. Ось робочий Xamarin / C # версія коду цієї відповіді, щоб заощадити час транскрипції іншим:

AppDelegate.cs

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

Клас Static OrientationUtility.cs:

public static class OrientationUtility
{
    public static void LockOrientation(UIInterfaceOrientationMask orientation)
    {
        var appdelegate = (AppDelegate) UIApplication.SharedApplication.Delegate;
        if(appdelegate != null)
        {
            appdelegate.OrientationLock = orientation;
        }
    }

    public static void LockOrientation(UIInterfaceOrientationMask orientation, UIInterfaceOrientation RotateToOrientation)
    {
        LockOrientation(orientation);

        UIDevice.CurrentDevice.SetValueForKey(new NSNumber((int)RotateToOrientation), new NSString("orientation"));
    }
}

Контролер перегляду:

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

Найкраще рішення для блокування та зміни орієнтації на портретному та альбомному режимах:

Перегляньте це відео на YouTube:

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

Цей підручник найкращий і простий.

або використовуйте код нижче:

Дивіться цю картинку

// 1- у другому контролері перегляду ми встановлюємо орієнтацію вліво, а в першому контролері перегляду - портрат:

// 2- якщо ви використовуєте NavigationController, вам слід додати розширення

import UIKit

class SecondViewController: UIViewController {


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

    override open var shouldAutorotate: Bool {
        return false
    }

    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return .landscapeLeft
    }

    override var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
        return .landscapeLeft
    }
    
    

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

//write The rest of your code in here


}

//if you use NavigationController, you should add this extension

extension UINavigationController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return topViewController?.supportedInterfaceOrientations ?? .allButUpsideDown
    
    }
}