Obrót orientacji jest nieco bardziej skomplikowany, jeÅ›li jesteÅ› wewnÄ…trz UINavigationController lub UITabBarController. Problem polega na tym, że jeÅ›li kontroler widoku jest osadzony w jednym z tych kontrolerów, kontroler nawigacji lub paska kart ma pierwszeÅ„stwo i podejmuje decyzje dotyczÄ…ce autorotacji i obsÅ‚ugiwanych orientacji.

Używam następujących 2 rozszerzeń na UINavigationController i UITabBarController tak, że kontrolery widoku, które są osadzone w jednym z tych kontrolerów, mogą decyzje.

Daj kontrolerom widoku moc!

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

Teraz możesz nadpisać metodÄ™ supportedInterfaceOrientations lub nadpisać shouldAutoRotate w kontrolerze widoku, który chcesz zablokować, w przeciwnym razie możesz pominąć nadpisania w innych kontrolerach widoku, które chcesz dziedziczyć domyÅ›lne zachowanie orientacji okreÅ›lone w plist aplikacji

Wyłącz Rotację

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

Blokada do konkretnego Orientacja

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

Teoretycznie powinno to działać dla wszystkich złożonych hierarchii kontrolerów widoku, ale zauważyłem problem z UITabBarController. Z jakiegoś powodu chce użyć domyślnej wartości orientacyjnej. Zapoznaj się z poniższym wpisem na blogu, jeśli chcesz dowiedzieć się, jak obejść niektóre z problemów:

Blokada Obrotu Ekranu

To mi się udało:

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

Wywołaj to w twoim poglądudidappear: method.

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

    [UIViewController attemptRotationToDeviceOrientation];
}

OdkryÅ‚em, że jeÅ›li jest to prezentowany kontroler widoku, możesz nadpisać preferredInterfaceOrientationForPresentation

Swift:

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

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

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

Ten sposób działa dla mnie w Swift 2 iOS 8.x:

PS (ta metoda nie wymaga nadpisywania funkcji orientacji, takich jak shouldautorotate na każdym kontrolerze viewController, tylko jednej metody na AppDelegate)

Zaznacz "wymaga pełnego ekranu" w projekcie ogólne informacje.

Więc, na AppDelegate.swift tworzy zmienną:

var enableAllOrientation = false

Więc, umieścić również ten func:

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

Więc w każdej klasie w Twoim projekcie możesz ustawić ten var w viewWillAppear:

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

Jeśli chcesz dokonać wyboru w oparciu o typ urządzenia, możesz to zrobić:

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

To powinno dziaÅ‚ać z iOS 6 w górÄ™, ale PrzetestowaÅ‚em go tylko na iOS 8. Podklasa UINavigationController i nadpisuje nastÄ™pujÄ…ce metody:

- (UIInterfaceOrientation)preferredInterfaceOrientationForPresentation {
    return UIInterfaceOrientationLandscapeRight;
}

- (BOOL)shouldAutorotate {
    return NO;
}

Lub zapytaj kontroler widocznego widoku

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

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

I wdrożyć tam metody.

Jest to odpowiedź na komentarze w Sid Shah ' s answer , dotyczące wyłączania animacji za pomocą:

[UIView setAnimationsEnabled:enabled];

Kod:

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

Po pierwsze-jest to zÅ‚y pomysÅ‚, w ogóle coÅ› nie tak z architekturÄ… aplikacji, ale, sh..t happens, jeÅ›li tak, możesz spróbować zrobić coÅ› takiego jak poniżej:

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

Niż, w 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
}

I kiedy chcesz zmienić orientację rób jak:

OrientationController.forceLockOrientation(.landscapeRight)

Uwaga: czasami urządzenie może nie aktualizować się z takiego połączenia, więc może być konieczne wykonanie następujących czynności

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

To wszystko

Na Xcode 8 Metody sÄ… konwertowane do wÅ‚aÅ›ciwoÅ›ci, wiÄ™c z Swift dziaÅ‚a:

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

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

override public var shouldAutorotate: Bool {
    return true
}

Jeśli używasz navigationViewController, powinieneś utworzyć własną superklasę i nadpisać:

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

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

  return YES;
}

To wyłączy obrót w SecondViewController ale jeśli naciśniesz swój SecondViewController Gdy Twoje urządzenie jest w orientacji pionowej, twój SecondViewController pojawi się w trybie pionowym.

Załóżmy, że używasz storyboard. Musisz utworzyć manual segue (How to ) i w swoim "onClick" "metoda": {]}

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

Wymusi to orientację poziomą przed wyłączeniem funkcji autorotate superclass.

Próbowałem wielu rozwiązań, ale ten, który zadziałał, jest następujący:

- (BOOL) shouldAutorotate {
    return NO;
}   

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

Możliwe orientacje z Dokumentacji Apple :

UIInterfaceOrientationUnknown

Nie można określić orientacji urządzenia.

UIInterfaceOrientationPortrait

[[2]}urzÄ…dzenie jest w trybie portretowym, z urzÄ…dzeniem trzymanym pionowo i przycisk home na dole.

UIInterfaceOrientationPortraitUpsidedown

[[2]}urządzenie jest w trybie portretowym, ale do góry nogami, z urządzeniem trzymanym w pozycji pionowej i przycisk home u góry.

UIInterfaceOrientationLandscapeLeft

[[2]}urzÄ…dzenie jest w trybie poziomym, z urzÄ…dzeniem trzymanym w pozycji pionowej i przycisk home po lewej stronie.

UIInterfaceOrientationLandscapeRight

UrzÄ…dzenie jest w tryb krajobrazowy, z urzÄ…dzeniem trzymanym w pozycji pionowej i przycisk home po prawej stronie.

Kombinacja odpowiedzi Sids i Koreys zadziałała dla mnie.

Rozszerzenie kontrolera Nawigacji:

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

Następnie wyłączanie rotacji w widoku pojedynczym

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

I obracajÄ…c siÄ™ do odpowiedniej orientacji przed segue

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

Górne rozwiązanie powyżej:

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

Nie działa dla mnie, gdy wywołałem go w viewDidAppear prezentowanego kontrolera widoku. Jednak zadziałało, gdy zadzwoniłem do niego w preparForSegue w prezentującym kontrolerze widoku.

(Sorry, za mało punktów reputacji, aby skomentować to rozwiązanie, więc musiałem dodać to w ten sposób)

Moje wymagania to

1. blokowanie wszystkich widoków w trybie portretowym
2. użyj AVPlayerViewController do odtwarzania wideo

Podczas odtwarzania wideo, jeśli jest to krajobraz, pozwól ekranowi obrócić krajobraz w prawo i w lewo. Jeśli jest to portret, Zablokuj Widok tylko w trybie portretowym.

Najpierw zdefiniuj supportedInterfaceOrientationsForWindow w AppDelegate.swift

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

Po drugie, w głównym kontrolerze widoku zdefiniuj następujące funkcje

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

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

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

NastÄ™pnie musisz podklasować 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
            }
        }
    }

ZastÄ…p te trzy funkcje w MyPlayerViewController.swift

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

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

Ponieważ użytkownik może obracać urządzenie w lewo lub w prawo, musimy ustawić automatyczne obracanie, aby było prawdziwe

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

Na koniec utwórz instancjÄ™ MyPlayerViewController w kontrolerze widoku i ustaw wartość wÅ‚aÅ›ciwoÅ›ci size.

let playerViewController = MyPlayerViewController()

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

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

Zainicjuj swojego gracza odpowiednim videoUrl, a nastÄ™pnie przypisz gracza do playerViewController. Szczęśliwego kodowania!

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

Zgodnie z odpowiedź Koreya Hintona

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

Wyłącz Rotację

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

Blokada do określonej orientacji

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

Próbowałem kilku rozwiązań tutaj i ważne jest, aby zrozumieć, że to kontroler widoku głównego, który określi, czy będzie się obracać, czy nie.

StworzyÅ‚em nastÄ™pujÄ…cy objective-C projekt github.com/GabLeRoux/RotationLockInTabbedViewChild {[8] } z roboczym przykÅ‚adem TabbedViewController, gdzie jeden widok potomny może siÄ™ obracać, a drugi widok potomny jest zablokowany w pionie.

Nie jest idealny, ale dziaÅ‚a i ten sam pomysÅ‚ powinien dziaÅ‚ać dla innego rodzaju widoki root, takie jak NavigationViewController. :)

[iOS9+] Gdyby ktoś tu ciągnął, bo żadne z powyższych rozwiązań nie zadziałało, a jeśli prezentujesz widok, chcesz zmienić orientację do segue ' a, możesz to sprawdzić.

Sprawdź typ prezentacji Twojego segue ' a. Mój był "ponad aktualnym kontekstem". Kiedy zmieniłem go na pełnoekranowy, zadziałało.

Dzięki @ GabLeRoux znalazłem takie rozwiązanie.

• ta zmiana dziaÅ‚a tylko w poÅ‚Ä…czeniu z powyższymi rozwiÄ…zaniami.

Zgodnie z rozwiÄ…zaniem pokazanym przez @ sid-sha musisz umieÅ›cić wszystko w metodzie viewDidAppear:, w przeciwnym razie nie dostaniesz didRotateFromInterfaceOrientation:, wiÄ™c coÅ› w stylu:

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

Moje rozwiÄ…zanie

W AppDelegate:

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

XXViewController jest kontrolerem widoku, który chcesz obsÅ‚ugiwać w trybie poziomym.

Wtedy rozwiÄ…zanie Sunny Shah zadziaÅ‚a w twoim XXViewController na dowolnej wersji iOS:

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

Jest to funkcja użytkowa, która pozwala znaleźć najlepszy Kontroler ViewController.

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
    }

}

Użyj tego, aby zablokować orientację kontrolera widoku, testowane na IOS 9:

// Zablokuj orientacjÄ™ w prawo do krajobrazu

-(UIInterfaceOrientationMask)supportedInterfaceOrientations {
    return UIInterfaceOrientationMaskLandscapeRight;
}

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

Wciąż trwa dyskusja na temat tego, jak najlepiej wykonać to zadanie, wiÄ™c pomyÅ›laÅ‚em, że podzielÄ™ siÄ™ moim (roboczym) podejÅ›ciem. Dodaj nastÄ™pujÄ…cy kod w swojej implementacji UIViewController:

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

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

-(BOOL)shouldAutorotate
{
    return NO;
}

- (UIInterfaceOrientationMask)supportedInterfaceOrientations
{
    return UIInterfaceOrientationMaskLandscapeLeft;
}

W tym przykÅ‚adzie należy również ustawić dozwolone orientacje urzÄ…dzenia na "poziomo w lewo" w ustawieniach projektu(lub bezpoÅ›rednio w info.plist). Po prostu zmieÅ„ orientacjÄ™, którÄ… chcesz wymusić, jeÅ›li chcesz czegoÅ› innego niż LandscapeLeft.

Kluczem dla mnie byÅ‚o attemptRotationToDeviceOrientation wezwanie viewWillAppear - bez tego Widok Nie obracaÅ‚by siÄ™ prawidÅ‚owo bez fizycznego obracania urzÄ…dzenia.

Mam ten sam problem i marnuję na niego tyle czasu. Więc teraz mam swoje rozwiązanie. Moje ustawienie aplikacji to tylko obsługa portretu.Jednak niektóre ekrany w mojej aplikacji muszą mieć tylko krajobraz.I fix it by have a variable isShouldRotate at AppDelegate. I funkcja w AppDelegate :

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

I wreszcie, gdy ViewControllerA wymaga stanu krajobrazu. Po prostu to zrób.: before push / present do viewcontrollera Przypisz powinno się zmienić na true . Nie zapomnij, gdy pop / close ten kontroler przypisać isShouldRotate false at viewWillDisappear.

Dla mnie, najwyższy poziom VC potrzebował zaimplementować przesłonięcia orientacyjne. Używanie VC w dół stosu nie będzie miało wpływu, jeśli top VC nie jest implementacja.

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

Tylko VC-Main jest słuchany, zasadniczo w moich testach.