it-swarm.com.de

Geräteorientierung in Swift iOS einstellen

Ich arbeite an einer Swift-App für das iPhone. In meiner Anwendung gibt es eine modale Ansicht, die nur im Hochformat angezeigt werden soll.

Meine Frage ist: Wie erzwinge ich programmgesteuert, dass das Telefon keine Rotation zulässt? Mit anderen Worten, ich suche nach Code, der es nicht zulässt, dass eine modale Ansicht im Querformat angezeigt wird (Einschalten der Hochrotationssperre).

Dies ist nur für eine modale Ansicht, daher kann ich die Rotation nicht für die gesamte App ausschalten. Andernfalls würde ich die Rotation ganz deaktivieren.

Ich habe Code in meiner Forschung gefunden hier Aber es ist in Ziel C, falls das hilft. Vielen Dank!

61
rocket101

Sie können diese Methoden in den ViewController jeder Ansicht einfügen, die ein Portrait sein muss:

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

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

Hallo für LandscapeLeft und LandscapeRight (Update Swift 2.0)

enter image description here Und Sie haben dies in Info 

enter image description here

Und UIController

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

override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
    return [UIInterfaceOrientationMask.LandscapeLeft,UIInterfaceOrientationMask.LandscapeRight]
}

Für PortraitUpsideDown und Portrait verwenden Sie das enter image description here

override func shouldAutorotate() -> Bool {
    if (UIDevice.currentDevice().orientation == UIDeviceOrientation.LandscapeLeft ||
        UIDevice.currentDevice().orientation == UIDeviceOrientation.LandscapeRight ||
        UIDevice.currentDevice().orientation == UIDeviceOrientation.Unknown) {
            return false
    }
    else {
        return true
    }
}

override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
    return [UIInterfaceOrientationMask.Portrait ,UIInterfaceOrientationMask.PortraitUpsideDown]
}

Nachricht aus Frankreich, Frohe Weihnachten!

Bearbeiten:

Andere Lösung:

extension UINavigationController {
    public override func shouldAutorotate() -> Bool {
        if visibleViewController is MyViewController {
            return true   // rotation
        } else {
            return false  // no rotation
        }
    }

    public override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
        return (visibleViewController?.supportedInterfaceOrientations())!
    }
}
67
YannickSteph

Swift 3

Orientierungsrotation ist komplizierter, wenn ein View-Controller in UINavigationController oder UITabBarController eingebettet ist. Der Controller für die Navigation oder die Registerkartenleiste hat Vorrang und entscheidet über Autorotation und unterstützte Orientierungen.

Verwenden Sie die folgenden Erweiterungen für UINavigationController und UITabBarController, damit View-Controller, die in einen dieser Controller eingebettet sind, die Entscheidungen treffen können:

UINavigationController-Erweiterung

extension UINavigationController {

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

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

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

UITabBarController-Erweiterung

extension UITabBarController {

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

override open var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation{
    get {
        if let selectedVC = selectedViewController{
            return selectedVC.preferredInterfaceOrientationForPresentation
        }
        return super.preferredInterfaceOrientationForPresentation
    }
}

override open var supportedInterfaceOrientations: UIInterfaceOrientationMask{
    get {
        if let selectedVC = selectedViewController{
            return selectedVC.supportedInterfaceOrientations
        }
        return super.supportedInterfaceOrientations
    }
}}

Jetzt können Sie die unterstütztenInterfaceOrientations, sollteAutoRotate und preferredInterfaceOrientationForPresentation im View-Controller, den Sie sperren möchten, außer Kraft setzen. Andernfalls können Sie die Überschreibungen in anderen View-Controllern auslassen, die das in der App-Liste Ihrer App angegebene Standardorientierungsverhalten übernehmen sollen.

Auf bestimmte Ausrichtung fixieren

class YourViewController: UIViewController {
open override var supportedInterfaceOrientations: UIInterfaceOrientationMask{
    get {
        return .portrait
    }
}}

Rotation deaktivieren

    class YourViewController: UIViewController {
open override var shouldAutorotate: Bool {
    get {
        return false
    }
}}

Bevorzugte Ausrichtung der Benutzeroberfläche für Präsentationen ändern

class YourViewController: UIViewController {
open override var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation{
    get {
        return .portrait
    }
}}
40
Dragos

Der obige Code funktioniert möglicherweise nicht, wenn der View Controller zu einem Navigations-Controller gehört. Wenn ja, muss es den Regeln des Navigationscontrollers gehorchen, auch wenn er selbst unterschiedliche Orientierungsregeln hat. Ein besserer Ansatz wäre, die Ansichtssteuerung für sich selbst entscheiden zu lassen, und die Navigationssteuerung wird die Entscheidung der obersten Ansichtssteuerung verwenden. 

Mit dieser generischen Erweiterung von UINavigationController können Sie sowohl die aktuelle Ausrichtung als auch das automatische Drehen unterstützen, um eine bestimmte Ausrichtung festzulegen:

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

        public override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
            return (visibleViewController?.supportedInterfaceOrientations())!
        }
    }

Jetzt können wir in Ihrem View Controller 

class ViewController: UIViewController {
    // MARK: Autoroate configuration

    override func shouldAutorotate() -> Bool {
        if (UIDevice.currentDevice().orientation == UIDeviceOrientation.Portrait ||
            UIDevice.currentDevice().orientation == UIDeviceOrientation.PortraitUpsideDown ||
            UIDevice.currentDevice().orientation == UIDeviceOrientation.Unknown) {
                return true
        }
        else {
            return false
        }
    }

    override func supportedInterfaceOrientations() -> Int {
        return Int(UIInterfaceOrientationMask.Portrait.rawValue) | Int(UIInterfaceOrientationMask.PortraitUpsideDown.rawValue)
    }
}

Ich hoffe es hilft. Danke

18
Vivek Parihar

Wenn jemand die Antwort will, denke ich, ich habe es gerade verstanden. Versuche dies:

  • Gehen Sie zu Ihrer .plist-Datei und überprüfen Sie alle Ausrichtungen.
  • Fügen Sie im View-Controller, den Sie zur Orientierung erzwingen möchten, folgenden Code hinzu:
override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
    return UIInterfaceOrientationMask.Portrait.toRaw().hashValue | UIInterfaceOrientationMask.PortraitUpsideDown.toRaw().hashValue
}

Ich hoffe es hilft !

BEARBEITEN:

Verwenden Sie den folgenden Code, um die Drehung zu erzwingen:

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

Es funktioniert für iOS 7 und 8!

11
lobodart

Dadurch wird die Autorotation der Ansicht deaktiviert:

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

Update

override func shouldAutorotate() -> Bool {
    if (UIDevice.currentDevice().orientation == UIDeviceOrientation.LandscapeLeft ||
        UIDevice.currentDevice().orientation == UIDeviceOrientation.LandscapeRight ||
        UIDevice.currentDevice().orientation == UIDeviceOrientation.Unknown) {
            return false;
    }
    else {
        return true;
    }
}

Wenn sich die App im Querformat befindet und Sie eine Ansicht zeigen, die im Hochformat angezeigt werden muss, kann die App ihre Ausrichtung in Hochformat ändern. 

11
tesla

 enter image description here

Go to your pList and add or remove the following as per your requirement:

"Supported Interface Orientations" - Array
"Portrait (bottom home button)" - String
"Portrait (top home button)" - String
"Supported Interface Orientations (iPad)" - Array
"Portrait (bottom home button)" - String
"Portrait (top home button)" - String
"Landscape (left home button)" - String
"Landscape (right home button)" - String

Hinweis: Diese Methode ermöglicht das Drehen einer gesamten App. 

OR

Erstellen Sie einen ParentViewController für UIViewControllers in einem Projekt (Vererbungsmethode).

//  UIappViewController.Swift

import UIKit

class UIappViewController: UIViewController {
          super.viewDidLoad()   
    }
//Making methods to lock Device orientation.
    override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
        return UIInterfaceOrientationMask.Portrait
    }
    override func shouldAutorotate() -> Bool {
        return false
    }                                                                                                                                       
    override func didReceiveMemoryWarning() {
            super.didReceiveMemoryWarning()
            // Dispose of any resources that can be recreated.
        }
    }

Ordnen Sie den übergeordneten Controller jedes Ansichtscontrollers als UIappViewController zu.

//  LoginViewController.Swift

import UIKit
import Foundation

class LoginViewController: UIappViewController{

    override func viewDidLoad()
    {
        super.viewDidLoad()

    }
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }
9
A.G

Für Swift 3, iOS 10 

override open var shouldAutorotate: Bool {
    return false
}

override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return .portrait
}

override open var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
    return .portrait
}

Es gibt jedoch einen Fehler mit der Einstellung shouldAutorotate, die derzeit unter iOS 9 nicht funktioniert.

8
CodeOverRide

Ändern Sie in der info.plist-Datei die gewünschten Ausrichtungen in "unterstützte Schnittstellenausrichtung".

In Swift die Art und Weise der Unterstützung von Dateien-> info.plist-> Unterstützung der Benutzeroberfläche.

6
Malu

Weitere Swift-ähnliche Version:

override func shouldAutorotate() -> Bool {
    switch UIDevice.currentDevice().orientation {
    case .Portrait, .PortraitUpsideDown, .Unknown:
        return true
    default:
        return false
    }
}

override func supportedInterfaceOrientations() -> Int {
    return Int(UIInterfaceOrientationMask.Portrait.rawValue) | Int(UIInterfaceOrientationMask.PortraitUpsideDown.rawValue)
}

UINavigationController von Vivek Parihar

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

Ich habe den ganzen Morgen gekämpft, um NUR Landschaft rechts/rechts zu erhalten. Ich entdeckte etwas wirklich Ärgerliches; Obwohl auf der Registerkarte "Allgemein" die Option "Hochformat" für die Geräteorientierung deaktiviert werden kann, müssen Sie die Plist selbst bearbeiten, um die Ausrichtung von Portrait und PortraitUpsideDown INTERFACE zu deaktivieren. Dies ist der letzte Schlüssel in der Plist: "Unterstützte Oberflächenorientierungen".

Die andere Sache ist, dass es scheint, dass Sie die "mask" -Versionen der Enumerationen verwenden müssen (z. B. UIInterfaceOrientationMask.LandscapeLeft), nicht nur die Orientierung. Der Code, der es für mich funktionierte (in meiner HauptansichtController):

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

override func supportedInterfaceOrientations() -> Int {
    return Int(UIInterfaceOrientationMask.LandscapeLeft.rawValue) | Int(UIInterfaceOrientationMask.LandscapeRight.rawValue)
}

Diese Kombination aus plist-Änderungen und Code zu verwenden, ist die einzige Möglichkeit, die Funktion korrekt auszuführen.

4
mrwheet

// Swift 2

override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
    let orientation: UIInterfaceOrientationMask =
    [UIInterfaceOrientationMask.Portrait, UIInterfaceOrientationMask.PortraitUpsideDown]
    return orientation
}
3
user3561494

Zwei Vorschläge mit der Lösung von @Vivek Parihar:

  1. Wenn wir einen viewController vorstellen, sollten wir in der navigationController-Erweiterung auf "visibleViewController" prüfen 

    extension UINavigationController {
    public override func shouldAutorotate() -> Bool {
        var shouldAutorotate = false
        if visibleViewController != nil {
            shouldAutorotate = visibleViewController.shouldAutorotate()
        }
        return shouldAutorotate
    }
    
    public override func supportedInterfaceOrientations() -> Int {
        return visibleViewController.supportedInterfaceOrientations()
    }
    }
    
  2. Wenn wir ein Aktionsblatt zum Präsentieren verwenden und der Benutzer sich nach unten dreht, wird das Aktionsblatt vom oberen Bildschirmrand aus geöffnet: P, um dies zu lösen, sollten wir nur das Portrait verwenden

    override func shouldAutorotate() -> Bool {
    if (UIDevice.currentDevice().orientation == UIDeviceOrientation.Portrait ||
        UIDevice.currentDevice().orientation == UIDeviceOrientation.Unknown) {
            return true
    }
    else {
        return false
    }
    

    }

    override func supportedInterfaceOrientations() -> Int {
        return Int(UIInterfaceOrientationMask.Portrait.rawValue)
    }
    
2
Nitesh

Schnell 2.2 

    func application(application: UIApplication, supportedInterfaceOrientationsForWindow window: UIWindow?) -> UIInterfaceOrientationMask {

    if self.window?.rootViewController?.presentedViewController is SignatureLandscapeViewController {

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

        if secondController.isPresented {

            return UIInterfaceOrientationMask.LandscapeLeft;

        } else {

            return UIInterfaceOrientationMask.Portrait;
        }

    } else {

        return UIInterfaceOrientationMask.Portrait;
    }
}
0
idris yıldız

Ab ios 10.0 benötigen wir set { self.orientations = newValue } zum Einrichten der Ausrichtung. Stellen Sie sicher, dass die Landscape-Eigenschaft in Ihrem Projekt aktiviert ist.

private var orientations = UIInterfaceOrientationMask.landscapeLeft
override var supportedInterfaceOrientations : UIInterfaceOrientationMask {
    get { return self.orientations }
    set { self.orientations = newValue }
}
0
Jack

Mein bescheidener Beitrag (Xcode 8, Swift 3):

func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
        if let rootViewController = self.topViewControllerWithRootViewController(rootViewController: window?.rootViewController) {
            if (rootViewController.responds(to: Selector(("canRotate")))) {
                // Unlock landscape view orientations for this view controller
                return .allButUpsideDown;
            }
        }
        return .portrait;        
    }

    private func topViewControllerWithRootViewController(rootViewController: UIViewController!) -> UIViewController? {
        if (rootViewController == nil) { return nil }
        if (rootViewController.isKind(of: (UITabBarController).self)) {
            return topViewControllerWithRootViewController(rootViewController: (rootViewController as! UITabBarController).selectedViewController)
        } else if (rootViewController.isKind(of:(UINavigationController).self)) {
            return topViewControllerWithRootViewController(rootViewController: (rootViewController as! UINavigationController).visibleViewController)
        } else if (rootViewController.presentedViewController != nil) {
            return topViewControllerWithRootViewController(rootViewController: rootViewController.presentedViewController)
        }
        return rootViewController
    }

... in der AppDelegate. Alle Kredite für Gandhi Mena: http://www.jairobjunior.com/blog/2016/03/05/wie- -Swift/

0
Ivan Morales

Swift 4:

Die einfachste Antwort, in meinem Fall, die Sicherstellung einer Onboarding-Tutorial-Ansicht, war nur Porträt.

extension myViewController {
    //manage rotation for this viewcontroller
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return .portrait
    }
}

Eezy-Peezy.

0
drew..