केवल स्विफ्ट में पोर्ट्रेट मोड में एक व्यू कंट्रोलर का ओरिएंटेशन लॉक कैसे करें

95

चूंकि मेरे ऐप को सभी अभिविन्यास के लिए समर्थन मिला। मैं विशिष्ट UIViewController के लिए केवल पोर्ट्रेट मोड को लॉक करना चाहूंगा।

उदाहरण के लिए मान लें कि यह Tabbed अनुप्रयोग था और जब साइन इन व्यू सामान्य रूप से दिखाई देता है, तो मैं केवल यही चाहता हूं कि साइन इन करें पोर्ट्रेट मोड पर केवल कोई फर्क नहीं पड़ता कि उपयोगकर्ता डिवाइस को कैसे घुमाए या वर्तमान डिवाइस ओरिएंटेशन कैसे होगा।

swift  uiviewcontroller  portrait  device-orientation 
— तिहा आंग
स्रोत
— क्रिस रूफ

जवाबों:

262

जब आपके पास एक जटिल दृश्य पदानुक्रम होता है, जैसे कई नेविगेशन नियंत्रक और / या टैब दृश्य नियंत्रक होने पर चीजें काफी गड़बड़ हो सकती हैं।

यह कार्यान्वयन इसे व्यक्तिगत दृश्य नियंत्रकों पर सेट करने के लिए डालता है, जब वे उप-परीक्षाओं के माध्यम से पुनरावृति करके उन्हें खोजने के लिए ऐप डेलिगेट पर भरोसा करने के बजाय, झुकाव को लॉक करना चाहते हैं।

स्विफ्ट 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)
}

अगर आईपैड या यूनिवर्सल ऐप

सुनिश्चित करें कि "पूर्ण स्क्रीन की आवश्यकता है" लक्ष्य सेटिंग्स में जाँच की जाती है -> सामान्य -> ​​परिनियोजन जानकारी। supportedInterfaceOrientationsForअगर जाँच नहीं हुई तो प्रतिनिधि को नहीं बुलाया जाएगा। यहां छवि विवरण दर्ज करें

— bmjohns
स्रोत
ऐसा लगता है कि यह कोड नियंत्रण है ... मुझे इसकी जांच करने दें, अच्छा उत्तर लगता है।
— तेह आंग
17
बहुत सारे पागलपनपूर्ण शोध के बाद, यह एकमात्र उत्तर है जो मैंने पाया कि मेरे लिए काम करता है। स्विफ्ट 3 - एक्सकोड 8.2.1
— जेवियर गार्सिया रुबियो
1
@pbm कंपनी में कई एप्लिकेशन मैं ऐप के दौरान विशिष्ट भागों में लॉक ओरिएंटेशन पर काम करता हूं, और सभी को कई वर्षों में ऐप स्टोर में कई बार अनुमोदित किया गया है। हालांकि, मैंने कहा, मैं गारंटी नहीं दे सकता कि Apple को इस सड़क के साथ कोई समस्या नहीं होगी। लेकिन अभी तक कोई समस्या नहीं है, और मैं काफी निश्चित हूं कि कई ऐप किसी न किसी रूप में ऐसा करते हैं।
— bmjohns
2
अगर जाँच हो रही है Requires full screen, तो यह ऐप को स्लाइड ओवर और स्प्लिट व्यू के लिए उपलब्ध रोक देगा। Apple द्वारा iPad पर मल्टीटास्किंग एन्हांसमेंट को अपनाना देखें । मेरे पास जवाब है कि मुझे सक्षम होने की आवश्यकता नहीं हैRequires full screen
— जॉन पैंग
2
इसका काम नहीं कर रहा है, दूसरा व्यू कॉन्ट्रोलर लेआउट ने केवल पोर्ट्रेट में इसके शो को अपडेट नहीं किया है।
— iCoder
27

स्विफ्ट 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)
    }

और जो डिवाइस फिजिकल ओरिएंटेशन के हिसाब से दूसरों के लिए स्क्रीन ओरिएंटेशन बनाएगा।

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

    }
— नाहिद रायहान
स्रोत
स्विफ्ट 4 के लिए यह निश्चित रूप से शीर्ष उत्तर है। यह वही है जो मुझे चाहिए था क्योंकि यह iOS कैमरा ऐप के व्यवहार की नकल करता है।
— nocdib
@ नाहिद क्या हम func application इस कार्य के साथ मूल प्रतिनिधियों को इस कार्य के साथ प्रतिस्थापित करते हैंfunc application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask { return self.orientationLock ?
— मूंदड़ा
समाधान की तलाश और कुछ प्रयासों के घंटे या दो के बाद, यह पूरी तरह से काम कर समाधान है। यह दृश्य के अभिविन्यास को सेट करता है, जब दृश्य लोड होता है, तो बल देता है, दूसरे दृश्य में जाने पर अनलॉक होता है, यह टैब नेविगेशन में काम करता है और कोड सरल और साफ है। साभार @Nahid
— Radek Sip
12

स्विफ्ट 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और उस पर इन गुणों को सेट कर सकते हैं ।

— अराश एत्माद
स्रोत
धन्यवाद। यह मेरे लिए अच्छा है क्योंकि मैं केवल पोर्ट्रेट के लिए एक विशिष्ट दृश्य को प्रतिबंधित करना चाहता हूं। पूरा ऐप नहीं।
— user3204765
सभी की जरूरत है कि विशिष्ट दृष्टिकोण को नियंत्रित करने के लिए नियंत्रण पर ध्यान केंद्रित करने के लिए उन्मुखीकरण की परवाह किए बिना उन्मुखीकरण और इस महान काम किया है!
— रयान बी।
9

पोर्ट्रेट को बल देने और उसे लॉक करने के लिए इस कोड को जोड़ें:

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 में - जो कुछ भी आप चाहते हैं कि आप जो भी अभिविन्यास चाहते हैं, उसके लिए समर्थित InterfaceOrientationsForWindow - AppDelegate सेट करें:

func application(application: UIApplication, supportedInterfaceOrientationsForWindow window: UIWindow?) -> UIInterfaceOrientationMask {
    return UIInterfaceOrientationMask.All
}
— वैलेन्टिन
स्रोत
धन्यवाद वैलेंटिन, मैंने वास्तव में आपकी मदद की सराहना की। लेकिन, आपने कोड नहीं निकाला। और मैंने अब हल कर लिया है। मैंने भी अपने प्रश्न का उत्तर दिया।
— थाहा आंग
7

यह आपकी समस्या और संबंधित अन्य के लिए एक सामान्य समाधान है।

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. अपने विशिष्ट व्यवहार के लिए अपने इच्छा व्यवहार के साथ एक प्रोटोकॉल बनाएँ, चित्र होगा।

प्रोटोकॉल ओरिएंटेशन

नोट: यदि आप चाहें, तो इसे UIHelper Class के शीर्ष में जोड़ें।

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
    }

अंतिम नोट्स:

  • यदि आप अधिक वर्ग चित्र मोड में हैं, तो बस उस प्रोटोकॉल का विस्तार करें।
  • यदि आप अन्य लोगों को दृश्य नियंत्रकों से चाहते हैं, तो अन्य प्रोटोकॉल बनाएं और समान संरचना का पालन करें।
  • यह उदाहरण पुश व्यू कंट्रोलर्स के बाद ओरिएंटेशन परिवर्तन के साथ समस्या को हल करता है
— एरियल एंटोनियो फंडोरा
स्रोत
इस समाधान की तरह, लेकिन मैंने यूआईहेल्पर को एक्सटेंशन के रूप में अधिक उपयोगी पाया।
— माइकल लॉन्ग
5

इस धागे में महान जवाब का एक गुच्छा, लेकिन कोई भी मेरी जरूरतों से मेल नहीं खाता। मेरे पास प्रत्येक टैब में नेविगेशन नियंत्रकों के साथ एक tabbed ऐप है, और एक दृश्य को घुमाने के लिए आवश्यक है, जबकि अन्य को चित्र में बंद करने की आवश्यकता है। नेविगेशन कंट्रोलर किसी भी कारण से, यह ठीक से साक्षात्कार का आकार नहीं ले रहा था। इस उत्तर के साथ संयोजन करके (स्विफ्ट 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 के वर्ग को नए बनाए गए उपवर्ग में बदलना न भूलें।

— russdub
स्रोत
5

स्विफ्ट के नए संस्करण के लिए यह प्रयास करें

override var shouldAutorotate: Bool {
    return false
}

override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return UIInterfaceOrientationMask.portrait
}

override var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
    return UIInterfaceOrientation.portrait
}
— खेमचार्त छुटपच
स्रोत
यह वही है जो मुझे चाहिए था! IPad नियंत्रक के लिए सभी अभिविन्यास विकल्प मान्य हैं और iPhone नियंत्रक केवल पोर्ट्रेट मोड के लिए इसे केवल इन तीन ओवरराइड्स में लिखकर - परफेक्ट।
— VYT
4

यहां एक सरल तरीका है जो मेरे लिए स्विफ्ट 4.2 (iOS 12.2) के साथ काम करता है, इसे इस तरह से रखें UIViewController, जिसके लिए आप कंधे को अक्षम करना चाहते हैं:

override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
    return .portrait
}

यह .portraitहिस्सा बताता है कि किस अभिविन्यास में रहना है, आप इसे अपनी इच्छानुसार बदल सकते हैं। विकल्प हैं: .portrait, .all, .allButUpsideDown, .landscape, .landscapeLeft, .landscapeRight, .portraitUpsideDown।

— GregT
स्रोत
2

अपने ऐप के सभी दृश्य के लिए लैंडस्केप ओरिएंटेशन सेट करने के लिए और ऑल ओरिएंटेशन के लिए केवल एक दृश्य की अनुमति दें (उदाहरण के लिए कैमरा रोल जोड़ने में सक्षम होने के लिए):

AppDelegate.swift में:

var adaptOrientation = false

में: didFishLaunchingWithOptions

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

अंतिम बात डिवाइस अभिविन्यास पर टिक करना है: - पोर्ट्रेट - लैंडस्केप लेफ्ट - लैंडस्केप राइट

— आईओएस फ्लो
स्रोत
2

के साथ नया एक्सटेंशन बनाएं

import UIKit

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

extension UITabBarController {
    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return .portrait
    }
}
— फेलिप किमियो
स्रोत
1

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

    }
}

और आपके निर्देशों का पालन किया, और स्विफ्ट 3 -> xcode संस्करण 8.2.1 के लिए सब कुछ पूरी तरह से काम करता है

— स्टेपन
स्रोत
1

IOS 10 और 11 के रूप में, iPad स्लाइड ओवर और स्प्लिट व्यू का समर्थन करता है। स्लाइड ओवर और स्प्लिट व्यू में एप्लिकेशन को सक्षम करने के लिए, अनियंत्रित Requires full screen होना चाहिए। यदि एप्लिकेशन स्लाइड ओवर और स्प्लिट व्यू का समर्थन करना चाहता है तो इसका मतलब है कि स्वीकृत उत्तर का उपयोग नहीं किया जा सकता है । यहां iPad पर Apple के एडॉप्टिंग मल्टीटास्किंग एन्हांसमेंट से अधिक देखें ।

मेरे पास एक समाधान है जो (1) को अनचेक करने की अनुमति देता है Requires full screen, (2) केवल एक फ़ंक्शन को लागू करने की अनुमति देता है appDelegate(विशेषकर यदि आप लक्ष्य दृश्य नियंत्रकों को संशोधित / संशोधित नहीं कर सकते हैं), और (3) पुनरावर्ती कॉल से बचें। न तो सहायक वर्ग की जरूरत है और न ही एक्सटेंशन की।

appDelegate.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क्योंकि मैं iPad पर स्लाइड ओवर और स्लाइड व्यू को सक्षम करना चाहता हूं। Info.plist में iPad के लिए सभी 4 अभिविन्यास का समर्थन करने के लिए एप्लिकेशन की आवश्यकता है Supported interface orientations (iPad):।

मेरा ऐप फेसबुक की तरह ही काम करता है: iPhone पर, ज्यादातर समय यह पोर्ट्रेट पर लॉक होता है। पूर्ण स्क्रीन में छवि देखने पर, उपयोगकर्ताओं को बेहतर दृश्य के लिए परिदृश्य को घुमाने की अनुमति देता है। IPad पर, उपयोगकर्ता किसी भी दृश्य नियंत्रकों में किसी भी अभिविन्यास को घुमा सकते हैं। इसलिए, जब iPad स्मार्ट कवर (लैंडस्केप बाएं) पर खड़ा होता है तो ऐप अच्छा दिखता है।

  1. IPad को कॉल करने के लिए application(_:supportedInterfaceOrientationsFor), Info.plist में, केवल iPad के लिए पोर्ट्रेट रखें। एप्लिकेशन स्लाइड ओवर + स्प्लिट व्यू क्षमता खो देगा। लेकिन आप किसी भी व्यू कंट्रोलर के लिए ओरिएंटेशन को केवल एक स्थान पर लॉक या अनलॉक कर सकते हैं और ViewController क्लास को संशोधित करने की आवश्यकता नहीं है।

  2. अंत में, इस फ़ंक्शन को व्यू कंट्रोलर के जीवन चक्र पर बुलाया जाता है, जब दृश्य प्रदर्शित / हटाया जाता है। यदि आपके ऐप को अन्य समय में अभिविन्यास लॉक / अनलॉक / बदलने की आवश्यकता है, तो यह काम नहीं कर सकता है

— जॉन पैंग
स्रोत
क्या यह iPhone के लिए काम कर रहा है? मैं अपने परिदृश्य में केवल एक दृश्य को नियंत्रित करना चाहता हूं।
— 15
हाँ। iPhone के लिए काम करते हैं। मैं चित्र और परिदृश्य दोनों में अपना एक दृश्य नियंत्रक चाहता हूं, और इसे खारिज करने के बाद चित्र पर लौटता हूं।
— जॉन पैंग
1

इसके लिए वास्तविक परीक्षण समाधान । मेरे उदाहरण के लिए मुझे अपना पूरा ऐप पोर्ट्रेट मोड में होना चाहिए, लेकिन केवल एक स्क्रीन का ओरिएंटेशन लैंडस्केप मोड में होना चाहिए। केवल पोर्ट्रेट मोड की जाँच करके, ऐप के लिए पोर्ट्रेट ओरिएंटेशन बनाएं

ऊपर वर्णित उत्तरों के रूप में 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)
}
— गुरप्रीत सिंह
स्रोत
1

मैंने थोड़ा प्रयोग किया और मैं इस समस्या के लिए स्वच्छ समाधान खोजने में कामयाब रहा। दृष्टिकोण दृश्य टैगिंग के माध्यम से दृश्य टैगिंग पर आधारित है

लक्ष्य 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 के साथ ओवरलैप किया गया है, तो चिह्नित दृश्य भी मिल जाएगा।

— व्लाडा
स्रोत
0

ऊपर @ bmjohn के उत्तर के लिए धन्यवाद। यहाँ उस उत्तर के कोड का एक काम करने वाला ज़ामरीन / सी # संस्करण है, दूसरों को प्रतिलेखन के समय को बचाने के लिए:

AppDelegate.cs

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

स्टेटिक ओरिएंटेशनUtility.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);
    }
— ccs_dev
स्रोत
मुझे समझ नहीं आता कि यह उत्तर कैसे प्रासंगिक है? उस व्यक्ति ने तेज में पूछा और आपने ज़मीरिन में दिया।
— मिहिर ओझा
0

चित्र और परिदृश्य पर लॉक और परिवर्तन अभिविन्यास के लिए सर्वश्रेष्ठ समाधान:

इस विडियो को यूट्यूब पर देखें:

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

यह ट्यूटोरियल सबसे अच्छा और सरल है।

या नीचे दिए गए कोड का उपयोग करें:

देखिए यह तस्वीर

// 1- दूसरे दृश्‍यक्रम में हम लैंडस्केप बनाते हैं और पहले दृश्‍यक्रम में हम पोर्ट्रेट सेट करते हैं:

// 2- अगर आप नेवीगेशन कंट्रोलर का उपयोग करते हैं, तो आपको एक्सटेंशन जोड़ना चाहिए

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
    
    }
}
— OliaPh
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.