अभिविन्यास परिवर्तन का पता कैसे लगाएं?

148

मैं स्विफ्ट का उपयोग कर रहा हूं और मैं चाहता हूं कि जब मैं परिदृश्य को घुमाऊं तो मैं एक यूआईईवीकॉन्ट्रोलर को लोड करने में सक्षम होऊं, क्या कोई मुझे सही दिशा में इंगित कर सकता है?

मुझे ऑनलाइन कुछ भी नहीं मिल रहा है और प्रलेखन द्वारा थोड़ा भ्रमित किया जा सकता है।

ios  swift  orientation-changes 
— डेविड
स्रोत
1
मुझे लगता है कि एपीआई नहीं बदला है, इसलिए इसे "didRotateToOrientation" और "willRotateToOrientation" होना चाहिए, ऐसा कुछ, Apple दस्तावेज़ीकरण पर एक नज़र डालें
— डेविड 'mArm' Ansermot
1
हाय @ mArm.ch, त्वरित उत्तर के लिए धन्यवाद! तो मैं इसे कैसे लागू करूंगा? (यह मेरा पहला ऐप है ... मैं IOS के लिए बहुत नया हूं) :)
— डेविड
मैंने अन्य लोगों के लिए, उत्तर के रूप में रिपॉस्ट किया। क्या आप इसे स्वीकार कर सकते हैं यदि यह आपके लिए ठीक है?
— डेविड 'mArm' Ansermot

जवाबों:

194

यहां बताया गया है कि मैंने इसे कैसे काम किया:

में AppDelegate.swiftअंदर didFinishLaunchingWithOptions समारोह मैं डाल:

NotificationCenter.default.addObserver(self, selector: #selector(AppDelegate.rotated), name: UIDevice.orientationDidChangeNotification, object: nil)

और फिर AppDelegate वर्ग के अंदर मैंने निम्नलिखित कार्य किया: 

func rotated() {
    if UIDeviceOrientationIsLandscape(UIDevice.current.orientation) {
        print("Landscape")
    }

    if UIDeviceOrientationIsPortrait(UIDevice.current.orientation) {
        print("Portrait")
    }
}

आशा है कि यह किसी और की मदद करता है!

धन्यवाद!

— डेविड
स्रोत
5
मैंने AppDelegate में AddObserver को जोड़ने की कोशिश की, लेकिन एक अनजाने चयनकर्ता के साथ CoreFoundation में एक SIGABRT प्राप्त करता रहा। हालाँकि, जब मैंने addObserver को एक viewDidLoad में स्थानांतरित किया, तो यह पहली बार देखा कि यह पूरी तरह से काम करता है। बस जानकारी के लिए अगर कोई एक ही मुद्दे पर आता है।
— फ्रैक्टलडॉक्टर
1
Im कोडिंग के लिए नया है, लेकिन selectorएक स्ट्रिंग प्रारूप नहीं होना चाहिए "rotated:"??
— गिरगिट
4
Im यकीन है कि केवल अगर आप तर्क स्वीकार कर रहे हैं (जो rotated()नहीं करता है)
— डेविड
26
सावधान रहें क्योंकि UIDeviceOrientationकुछ अलग है UIInterfaceOrientation.. यह इसलिए है क्योंकि UIDeviceOrientationयह भी नीचे का पता लगाता है और झुकाव का सामना करता है जिसका अर्थ है कि आपका कोड चित्र और परिदृश्य के बीच बेतरतीब ढंग से कूद सकता है यदि आपका डिवाइस लगभग सपाट लेकिन थोड़ा असमान सतह पर टिकी हुई है (यानी प्रोटेस्टिंग पर पत्थर मार रहा है) 6 / 6s का कैमरा)
— liamnichols
4
यदि फोन अक्षम ऑटो रोटेशन के लिए यह विधि काम नहीं करता है।
— चेंगसम
178 
override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
    if UIDevice.current.orientation.isLandscape {
        print("Landscape")
    }
    if UIDevice.current.orientation.isFlat {
        print("Flat")
    } else {
        print("Portrait")
    }
}
— मिरोस्लाव ęwięcicki
स्रोत
71
इसे रोटेशन कहा जाएगा। यदि आपको जरूरत है जैसे कि रोटेशन के बाद फ्रेम का आकार तो यह समाधान काम नहीं करेगा।
— वोट दें
विस्तार में काम नहीं किया। परिदृश्य या चित्र अभी भी "पोर्टेबेट" प्रिंट करते हैं
— टॉमस्वायर
4
यदि फोन अक्षम ऑटो रोटेशन के लिए यह विधि काम नहीं करता है।
— चेंगसम
5
iPad पर, चूंकि आकार वर्ग परिदृश्य और चित्र दोनों के लिए समान नियमित है, इसलिए इस पद्धति को कभी नहीं कहा जाता है।
— जैकी
यदि डिवाइस लौटाता है तो यह भी विफल हो जाएगा। developer.apple.com/documentation/uikit/uideviceorientation/…
— कोडबेंडर
57

कैमरे का उपयोग करते समय रोटेशन का पता लगाने की आवश्यकता है AVFoundation, और पाया कि didRotate( अब पदावनत ) और willTransitionविधियाँ मेरी आवश्यकताओं के लिए अविश्वसनीय थीं। डेविड द्वारा पोस्ट की गई अधिसूचना का उपयोग करते हुए काम किया, लेकिन स्विफ्ट 3.x / 4.x के लिए वर्तमान नहीं है।

स्विफ्ट 4.2 अधिसूचना नाम बदल दिया गया है।

बंद मूल्य स्विफ्ट 4.0 के समान ही रहता है:

var didRotate: (Notification) -> Void = { notification in
        switch UIDevice.current.orientation {
        case .landscapeLeft, .landscapeRight:
            print("landscape")
        case .portrait, .portraitUpsideDown:
            print("Portrait")
        default:
            print("other")
        }
    }

स्विफ्ट 4.2 के लिए अधिसूचना सेट करने के लिए :

NotificationCenter.default.addObserver(forName: UIDevice.orientationDidChangeNotification,
                                       object: nil,
                                       queue: .main,
                                       using: didRotate)

स्विफ्ट 4.2 के लिए अधिसूचना फाड़ने के लिए :

NotificationCenter.default.removeObserver(self,
                                          name: UIDevice.orientationDidChangeNotification,
                                          object: nil)

पदावनत बयान के संबंध में , मेरी प्रारंभिक टिप्पणी भ्रामक थी, इसलिए मैं इसे अद्यतन करना चाहता था। जैसा कि उल्लेख @objcकिया गया है, अनुमान का उपयोग पदावनत किया गया है, जो बदले में ए का उपयोग करने की आवश्यकता थी #selector। इसके बजाय एक क्लोजर का उपयोग करके, इससे बचा जा सकता है और आपके पास अब एक समाधान है जिसे अमान्य चयनकर्ता को कॉल करने के कारण क्रैश से बचना चाहिए।

यहाँ नीचे सब कुछ XCode 10 और iOS 4.2 के रूप में अप्रचलित है

स्विफ्ट 4.0 स्विफ्ट 4.0 के साथ, Apple ने हमें इसके इस्तेमाल से बचने के लिए प्रोत्साहित किया है #selector, इसलिए यह दृष्टिकोण अब एक पूर्ण ब्लॉक का उपयोग करता है। यह दृष्टिकोण स्विफ्ट 3.x के साथ भी पीछे की ओर संगत है और आगे जाने के लिए अनुशंसित दृष्टिकोण होगा।

यह संकलक चेतावनी है जिसे आप स्विफ्ट 4.x परियोजना में प्राप्त करेंगे यदि आप अनुमान #selectorके अपव्यय के कारण फ़ंक्शन का उपयोग करते @objcहैं:

यहाँ छवि विवरण दर्ज करें

इस परिवर्तन पर तेजी से विकास में प्रवेश ।

कॉलबैक सेट करें:

// If you do not use the notification var in your callback, 
// you can safely replace it with _
    var didRotate: (Notification) -> Void = { notification in
        switch UIDevice.current.orientation {
        case .landscapeLeft, .landscapeRight:
            print("landscape")
        case .portrait, .portraitUpsideDown:
            print("Portrait")
        default:
            print("other")
        }
    }

अधिसूचना सेट करें:

NotificationCenter.default.addObserver(forName: .UIDeviceOrientationDidChange,
                                       object: nil,
                                       queue: .main,
                                       using: didRotate)

इसके चीथड़े कर दो:

NotificationCenter.default.removeObserver(self, name: .UIDeviceOrientationDidChange, object: nil)
— CodeBender
स्रोत
4
क्या आपके पास संदर्भ है जहां Apple स्विफ्ट 4 में #selector के उपयोग को हतोत्साहित करने की बात कर रहा है? मैं पढ़ना चाहूंगा कि वे ऐसा क्यों कह रहे हैं।
— जेफजेव
@ जेफज्व निश्चित रूप से, मेरे पास एक Apple दस्तावेज़ से सीधा लिंक नहीं है, लेकिन मैंने कंपाइलर चेतावनी का स्क्रीनशॉट शामिल किया है जो कि XCode प्रदान करता है यदि आप पिछले दृष्टिकोण का उपयोग करते हैं।
— कोडबेंडर
1
मैंने स्विफ्ट-इवोल्यूशन के लिए एक लिंक जोड़ा है जो बदलाव पर चर्चा करता है।
— कोडबेंडर
1
@ कोडबेंडर: संकलक चेतावनी का मतलब यह नहीं है कि आप क्या सुझाव देते हैं। #selector को ह्रास नहीं किया जा रहा है, केवल "@objc" निष्कर्ष। इसका मतलब यह है कि किसी फ़ंक्शन को #selector के रूप में उपयोग करते समय आपको इसे स्पष्ट रूप से चिह्नित करना होगा, ताकि कंपाइलर अतिरिक्त सही कोड उत्पन्न करेगा क्योंकि कंपाइलर अब आपके उपयोग से इसे हटाने की कोशिश नहीं करेगा। इसलिए, यदि आप अपने स्विफ्ट 3.0 समाधान में "रोट" (फंक) में "@obj" जोड़ते हैं, तो कोड चेतावनी के बिना संकलन करेगा।
— मिथलैंडिया
धन्यवाद @Mythlandia, मैंने अपने प्रारंभिक बयान पर भ्रम को हल करने के लिए उत्तर को अपडेट किया।
— कोडबेंडर
19

की -orientationसंपत्ति का उपयोग करना UIDeviceसही नहीं है (भले ही यह अधिकांश मामलों में काम कर सके) और कुछ बग पैदा कर सकता है, उदाहरण के लिए UIDeviceOrientation, डिवाइस के उन्मुखीकरण पर भी विचार करें यदि यह ऊपर या नीचे का सामना करता है, तो UIInterfaceOrientationउन लोगों के लिए दुश्मनी में कोई प्रत्यक्ष जोड़ी नहीं है। मान।
इसके अलावा, यदि आप अपने ऐप को कुछ विशेष अभिविन्यास में लॉक करते हैं, तो UIDevice आपको उस खाते को ध्यान में रखे बिना डिवाइस ओरिएंटेशन देगा।
दूसरी तरफ iOS8 ने वर्ग interfaceOrientationपर संपत्ति को हटा दिया है UIViewController।
इंटरफ़ेस अभिविन्यास का पता लगाने के लिए 2 विकल्प उपलब्ध हैं:

  • स्टेटस बार ओरिएंटेशन का उपयोग करें
  • IPhone पर आकार वर्ग का उपयोग करें, यदि वे ओवरराइड नहीं हैं, तो वे आपको वर्तमान इंटरफ़ेस अभिविन्यास को समझने का एक तरीका दे सकते हैं

अभी भी गायब है इंटरफ़ेस अभिविन्यास के बदलाव की दिशा को समझने का एक तरीका है, जो एनिमेशन के दौरान बहुत महत्वपूर्ण है।
WWDC 2014 के सत्र में "iOS8 में कंट्रोलर एडवांसमेंट देखें" स्पीकर उस समस्या का भी समाधान प्रदान करता है, जो विधि को प्रतिस्थापित करता है -will/DidRotateToInterfaceOrientation।

यहाँ प्रस्तावित समाधान आंशिक रूप से लागू किया गया है, यहाँ अधिक जानकारी :

func viewWillTransitionToSize(size: CGSize, withTransitionCoordinator coordinator: UIViewControllerTransitionCoordinator) {
        let orientation = orientationFromTransform(coordinator.targetTransform())
        let oldOrientation = UIApplication.sharedApplication().statusBarOrientation
        myWillRotateToInterfaceOrientation(orientation,duration: duration)
        coordinator.animateAlongsideTransition({ (ctx) in
            self.myWillAnimateRotationToInterfaceOrientation(orientation,
            duration:duration)
            }) { (ctx) in
                self.myDidAnimateFromInterfaceOrientation(oldOrientation)
        }
    }
— एंड्रिया
स्रोत
11

मुझे पता है कि यह सवाल है Swift, लेकिन चूंकि यह Google खोज के लिए शीर्ष लिंक में से एक है और यदि आप उसी कोड की तलाश में हैं Objective-C:

// add the observer
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(rotated:) name:UIDeviceOrientationDidChangeNotification object:nil];

// remove the observer
[[NSNotificationCenter defaultCenter] removeObserver:self name:UIDeviceOrientationDidChangeNotification object:nil];

// method signature
- (void)rotated:(NSNotification *)notification {
    // do stuff here
}
— mikeho
स्रोत
11

आसान, यह iOS8 और 9 / Swift 2 / Xcode7 में काम करता है, बस इस कोड को अपने viewcontroller.swift के अंदर रखें। यह हर अभिविन्यास परिवर्तन के साथ स्क्रीन आयामों को प्रिंट करेगा, आप इसके बजाय अपना कोड डाल सकते हैं:

override func didRotateFromInterfaceOrientation(fromInterfaceOrientation: UIInterfaceOrientation) {
        getScreenSize()
    }
    var screenWidth:CGFloat=0
    var screenHeight:CGFloat=0
    func getScreenSize(){
        screenWidth=UIScreen.mainScreen().bounds.width
        screenHeight=UIScreen.mainScreen().bounds.height
        print("SCREEN RESOLUTION: "+screenWidth.description+" x "+screenHeight.description)
    }
— जोश
स्रोत
5
इस फ़ंक्शन को पदावनत किया गया, "viewWillTransitionToSize: withTransitionCoordinator:" का उपयोग करें
— Masa S-AiYa
बगल में रखा जा रहा है, didRotateFromInterfaceOrientation()मज़बूती से काम नहीं करता है। इसमें कुछ घुमाव याद आते हैं। iewWillTransitionToSize:withTransitionCoordinator:ठीक काम करता है।
— Andrej
@Andrej बहुत सारी बातें अब 3 स्विफ्ट की बदौलत खत्म हो गई हैं
— जोश
9

मुझे ओरिएंटेशन नोटिफिकेशन चेक करना पसंद है क्योंकि आप इस फीचर को किसी भी क्लास में जोड़ सकते हैं, व्यू या व्यू कंट्रोलर होने की कोई जरूरत नहीं है। यहां तक ​​कि आपके ऐप के प्रतिनिधि में भी।

स्विफ्ट 5:

    //ask the system to start notifying when interface change
    UIDevice.current.beginGeneratingDeviceOrientationNotifications()
    //add the observer
    NotificationCenter.default.addObserver(
        self,
        selector: #selector(orientationChanged(notification:)),
        name: UIDevice.orientationDidChangeNotification,
        object: nil)

अधिसूचना को कैच करने से

    @objc func orientationChanged(notification : NSNotification) {
        //your code there
    }
— अल्बर्टो स्कम्पिनी
स्रोत
8

ऑब्जेक्टिव सी में

-(void)viewWillTransitionToSize:(CGSize)size withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator

स्विफ्ट में

func viewWillTransitionToSize(size: CGSize, withTransitionCoordinator coordinator: UIViewControllerTransitionCoordinator)

अभिविन्यास परिवर्तन का पता लगाने के लिए इस विधि को ओवरराइड करें।

— महेंद्र
स्रोत
8

स्विफ्ट 3 | UIDeviceOrientationDidChange अधिसूचना बहुत बार देखी गई

निम्नलिखित कोड प्रिंट करता है "deviceDidRotate" हर बार जब आपका डिवाइस 3 डी स्पेस में ओरिएंटेशन बदलता है - चाहे पोर्ट्रेट से लैंडस्केप ओरिएंटेशन में कोई बदलाव हो। उदाहरण के लिए, यदि आप अपने फोन को पोर्ट्रेट ओरिएंटेशन में रखते हैं और इसे आगे और पीछे झुकाते हैं - डिवाइसडायोटेट () बार-बार कहा जाता है।

override func viewDidLoad() {
    super.viewDidLoad()
    NotificationCenter.default.addObserver(
        self, 
        selector:  #selector(deviceDidRotate), 
        name: .UIDeviceOrientationDidChange, 
        object: nil
    )
}

func deviceDidRotate() {
    print("deviceDidRotate")
}

इसके आस-पास काम करने के लिए आप पिछले डिवाइस ओरिएंटेशन को पकड़ सकते हैं और डिवाइसड्रेडोटेट () में बदलाव की जांच कर सकते हैं।

var previousDeviceOrientation: UIDeviceOrientation = UIDevice.current.orientation

override func viewDidLoad() {
    super.viewDidLoad()
    NotificationCenter.default.addObserver(
        self, 
        selector:  #selector(deviceDidRotate), 
        name: .UIDeviceOrientationDidChange, 
        object: nil
    )
}

func deviceDidRotate() {
    if UIDevice.current.orientation == previousDeviceOrientation { return }
    previousDeviceOrientation = UIDevice.current.orientation
    print("deviceDidRotate")
}

या आप एक अलग अधिसूचना का उपयोग कर सकते हैं जो केवल तब ही कहा जाता है जब डिवाइस परिदृश्य से चित्र में बदलता है। इस मामले में आप UIApplicationDidChangeStatusBarOrientationअधिसूचना का उपयोग करना चाहते हैं ।

override func viewDidLoad() {
    super.viewDidLoad()
    NotificationCenter.default.addObserver(
        self, 
        selector:  #selector(deviceDidRotate), 
        name: .UIApplicationDidChangeStatusBarOrientation, 
        object: nil
    )
}

func deviceDidRotate() {
    print("deviceDidRotate")
}
— डेरेक सोइक
स्रोत
6

स्विफ्ट 3.0 में अभिविन्यास परिवर्तन का पता लगाने के लिए पूर्ण कार्य कार्यान्वयन।

मैं क्योंकि फोन झुकाव के इस कार्यान्वयन का उपयोग करने का फैसला किया face upऔर face downमेरे लिए महत्वपूर्ण थे, और मैं केवल एक बार मुझे पता था कि उन्मुखीकरण निर्दिष्ट स्थिति में थे बदलने के लिए दृश्य चाहता था। 

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        //1
        NotificationCenter.default.addObserver(self, selector: #selector(deviceOrientationDidChange), name: NSNotification.Name.UIDeviceOrientationDidChange, object: nil)

    }

    deinit {
        //3
        NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIDeviceOrientationDidChange, object: nil)
    }

    func deviceOrientationDidChange() {
        //2
        switch UIDevice.current.orientation {
        case .faceDown:
            print("Face down")
        case .faceUp:
            print("Face up")
        case .unknown:
            print("Unknown")
        case .landscapeLeft:
            print("Landscape left")
        case .landscapeRight:
            print("Landscape right")
        case .portrait:
            print("Portrait")
        case .portraitUpsideDown:
            print("Portrait upside down")
        }
    }

}

नोट करने के लिए महत्वपूर्ण टुकड़े हैं:

  1. आप DeviceOrientationDidChange अधिसूचना स्ट्रीम को सुनें और इसे फ़ंक्शन डिवाइस पर बाँध दें ।OrientationDidChange
  2. आप तब डिवाइस ओरिएंटेशन पर स्विच करते हैं, ध्यान रखें कि unknownकई बार ओरिएंटेशन हो।
  3. किसी भी अधिसूचना की तरह, व्यूकंट्रोलर के विखंडित होने से पहले, अधिसूचना स्ट्रीम का अवलोकन बंद करना सुनिश्चित करें।

आशा है कि कोई इसे मददगार मिले।

— रॉब नॉरबैक
स्रोत
धन्यवाद, महान
— मोहम्मद रजीपुर
इसलिए मैं भ्रमित हूं, वर्तमान में मेरे सभी दृश्य चित्र पर आधारित परिदृश्य पर समायोजित होते हैं, लेकिन अगर डिवाइस फेस-अप है तो यह नहीं बदलता है? फेस-अप होने पर मैं उसी प्रभाव को प्राप्त करने के लिए आपके उपरोक्त कोड का उपयोग कैसे करूंगा !?
— पारिवारिक टेक
क्या आप थोड़ा और संदर्भ दे सकते हैं? मुझे यकीन नहीं है कि आप किस प्रभाव का उल्लेख कर रहे हैं। यह कोड केवल अभिविन्यास का पता लगाने के लिए काम करता है। यदि आप अभिविन्यास का पता लगाने के लिए कई तरीकों का उपयोग कर रहे हैं तो आप मुसीबत में पड़ सकते हैं।
— 19 नॉर्ब में रॉब नॉरबैक
6 
override func didRotate(from fromInterfaceOrientation: UIInterfaceOrientation) {
    //swift 3
    getScreenSize()
}


func getScreenSize(){
   let screenWidth = UIScreen.main.bounds.width
   let  screenHeight = UIScreen.main.bounds.height
    print("SCREEN RESOLUTION: \(screenWidth.description) x \(screenHeight.description)")
}
— जीत गांधी
स्रोत
सबसे साफ जवाब। मेरे लिए काम किया।
— डोराद
अब इसे हटा दिया गया है
— अजीज जावेद
5

यदि आप कुछ करना चाहते हैं, तो रोटेशन पूरा हो गया है, तो आप UIViewControllerTransitionCoordinatorइस तरह से पूर्ण हैंडलर का उपयोग कर सकते हैं

public override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
    super.viewWillTransition(to: size, with: coordinator)

    // Hook in to the rotation animation completion handler
    coordinator.animate(alongsideTransition: nil) { (_) in
        // Updates to your UI...
        self.tableView.reloadData()
    }
}
— डेविड पेटीग्रेव
स्रोत
5

IOS 8 के बाद से यह इसे करने का सही तरीका है।

override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
    super.viewWillTransition(to: size, with: coordinator)

    coordinator.animate(alongsideTransition: { context in
        // This is called during the animation
    }, completion: { context in
        // This is called after the rotation is finished. Equal to deprecated `didRotate`
    })
}
— PatrickDotStar
स्रोत
4

जाँच करें कि क्या रोटेशन के साथ बदल गया था: viewWillTransitionToSize(size: CGSize, withTransitionCoordinator coordinator: UIViewControllerTransitionCoordinator)

साथ coordinator.animateAlongsideTransition(nil) { (UIViewControllerTransitionCoordinatorContext)आप देख सकते हैं कि संक्रमण समाप्त हो गया है।

नीचे देखें कोड:

override func viewWillTransitionToSize(size: CGSize, withTransitionCoordinator coordinator: UIViewControllerTransitionCoordinator) {

    super.viewWillTransitionToSize(size, withTransitionCoordinator: coordinator)

    coordinator.animateAlongsideTransition(nil) { (UIViewControllerTransitionCoordinatorContext) in
        // if you want to execute code after transition finished
        print("Transition finished")
    }

    if size.height < size.width {
        // Landscape
        print("Landscape")
    } else {
        // Portrait
        print("Portrait")
    }

}
— SDW
स्रोत
4

यहाँ उपकरण अभिविन्यास का पता लगाने का एक आसान तरीका है: ( स्विफ्ट 3 )

override func willRotate(to toInterfaceOrientation: UIInterfaceOrientation, duration: TimeInterval) {
            handleViewRotaion(orientation: toInterfaceOrientation)
        }

    //MARK: - Rotation controls
    func handleViewRotaion(orientation:UIInterfaceOrientation) -> Void {
        switch orientation {
        case .portrait :
            print("portrait view")
            break
        case .portraitUpsideDown :
            print("portraitUpsideDown view")
            break
        case .landscapeLeft :
            print("landscapeLeft view")
            break
        case .landscapeRight :
            print("landscapeRight view")
            break
        case .unknown :
            break
        }
    }
— राम माधवन
स्रोत
2
willRotateअब बेहतर उपयोग किया जाता है viewWillTransition।
— प्री
4

स्विफ्ट 4:

override func viewWillAppear(_ animated: Bool) {
    NotificationCenter.default.addObserver(self, selector: #selector(deviceRotated), name: UIDevice.orientationDidChangeNotification, object: nil)
}

override func viewWillDisappear(_ animated: Bool) {
    NotificationCenter.default.removeObserver(self, name: UIDevice.orientationDidChangeNotification, object: nil)
}

@objc func deviceRotated(){
    if UIDevice.current.orientation.isLandscape {
        //Code here
    } else {
        //Code here
    }
}

विभिन्न दृश्य नियंत्रकों में पता लगाने की आवश्यकता होने पर बहुत सारे उत्तर मदद नहीं करते हैं। यह एक चाल है।

— जोएल
स्रोत
आपको यह भी जांचने की आवश्यकता है कि क्या डिवाइस को घुमाया गया था जबकि दृश्य नियंत्रक गायब हो गया था (अन्य दृश्य नियंत्रक के चालू होने पर खोला गया है)। वास्तव में, आप छोड़ सकते हैं viewWillDisappearऔर जोड़ने addObserverमें viewDidLoad। iOS स्वचालित रूप से व्यू कंट्रोलर को अनसब्सक्राइब करता है।
— अलेक्जेंडर वोल्कोव
आप भूल गएUIDevice.current.orientation.isFlat
— user924
3

मेरे दृष्टिकोण क्या के समान है bpedit ऊपर से पता चलता है, लेकिन एक iOS 9+ ध्यान देने के साथ। जब दृश्य घूमता है तो मैं FSCalendar के दायरे को बदलना चाहता था ।

override func viewWillTransitionToSize(size: CGSize, withTransitionCoordinator coordinator: UIViewControllerTransitionCoordinator) {
    super.viewWillTransitionToSize(size, withTransitionCoordinator: coordinator)

    coordinator.animateAlongsideTransition({ (context) in
        if size.height < size.width {
            self.calendar.setScope(.Week, animated: true)
            self.calendar.appearance.cellShape = .Rectangle
        }
        else {
            self.calendar.appearance.cellShape = .Circle
            self.calendar.setScope(.Month, animated: true)

        }

        }, completion: nil)
}

यह नीचे काम किया है, लेकिन मैं इसके बारे में स्पष्ट महसूस किया :)

coordinator.animateAlongsideTransition({ (context) in
        if size.height < size.width {
            self.calendar.scope = .Week
            self.calendar.appearance.cellShape = .Rectangle
        }
        }) { (context) in
            if size.height > size.width {
                self.calendar.scope = .Month
                self.calendar.appearance.cellShape = .Circle
            }
    }
— कर्टिस फॉरेस्टर
स्रोत
2

मैं कक्षा UIUserInterfaceSizeClassमें परिवर्तित अभिविन्यास का पता लगाने के लिए UIViewControllerउसी तरह उपयोग करता हूं :

override func willTransition(to newCollection: UITraitCollection, with coordinator: UIViewControllerTransitionCoordinator) {

    let isiPadLandscapePortrait = newCollection.horizontalSizeClass == .regular && newCollection.verticalSizeClass == .regular
    let isiPhonePlustLandscape = newCollection.horizontalSizeClass == .regular && newCollection.verticalSizeClass == .compact
    let isiPhonePortrait = newCollection.horizontalSizeClass == .compact && newCollection.verticalSizeClass == .regular
    let isiPhoneLandscape = newCollection.horizontalSizeClass == .compact && newCollection.verticalSizeClass == .compact

     if isiPhonePortrait {
         // do something...
     }
}
— pableiros
स्रोत
1

स्विफ्ट 3 के लिए

override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
    if UIDevice.current.orientation.isLandscape {
        //Landscape
    }
    else if UIDevice.current.orientation.isFlat {
        //isFlat
    }
    else {
        //Portrait
    }
}
— ममता
स्रोत
आप भूल गएUIDevice.current.orientation.isFlat
— user924
1

स्विफ्ट 5

डिवाइस अभिविन्यास परिवर्तन की सूचनाएं प्राप्त करने के लिए सेटअप वर्ग:

class MyClass {

    ...

    init (...) {

        ...

        super.init(...)

        // subscribe to device orientation change notifications
        UIDevice.current.beginGeneratingDeviceOrientationNotifications()
        NotificationCenter.default.addObserver(self, selector: #selector(orientationChanged), name: UIDevice.orientationDidChangeNotification, object: nil)

        ...

    }

    ...

}

सेटअप हैंडलर कोड:

@objc extension MyClass {
    func orientationChanged(_ notification: NSNotification) {
        let device = notification.object as! UIDevice
        let deviceOrientation = device.orientation

        switch deviceOrientation {
        case .landscapeLeft:   //do something for landscape left
        case .landscapeRight:  //do something for landscape right
        case .portrait:        //do something for portrait
        case .portraitUpsideDown: //do something for portrait upside-down 
        case .faceDown:        //do something for face down
        case .faceUp:          //do something for face up
        case .unknown:         //handle unknown
        @unknown default:      //handle unknown default
        }
    }
}
— जैकब बरनार्ड
स्रोत
0 
- (void)viewDidLoad {
  [super viewDidLoad];
  [[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(OrientationDidChange:) name:UIDeviceOrientationDidChangeNotification object:nil];
}

-(void)OrientationDidChange:(NSNotification*)notification {
  UIDeviceOrientation Orientation=[[UIDevice currentDevice]orientation];

  if(Orientation==UIDeviceOrientationLandscapeLeft || Orientation==UIDeviceOrientationLandscapeRight) {
    NSLog(@"Landscape");
  } else if(Orientation==UIDeviceOrientationPortrait) {
    NSLog(@"Potrait Mode");
  }
}

नोट: UIViewController की पहचान करने के लिए बस इस कोड का उपयोग करें जिसमें अभिविन्यास है

— मननं ब्रह्मम्
स्रोत
आपका कोड प्रोजेक्ट में काम नहीं कर रहा है। क्या मुझे कुछ और करने की ज़रूरत है?
— सैयद अली सलमान
0 
override func viewDidLoad() {
    NotificationCenter.default.addObserver(self, selector: #selector(MyController.rotated), name: UIDevice.orientationDidChangeNotification, object: nil)
//...
}

@objc
private func rotated() {
    if UIDevice.current.orientation.isLandscape {

    } else if UIDevice.current.orientation.isPortrait {

    }

    //or you can check orientation separately UIDevice.current.orientation
    //portrait, portraitUpsideDown, landscapeLeft, landscapeRight... 

}
— yoAlex5
स्रोत
0

IOS 13.1.2 के साथ, ओरिएंटेशन हमेशा 0 वापस आता है जब तक कि डिवाइस को घुमाया नहीं जाता है। मुझे UIDevice.current.beginGeneratingDeviceOrientationNotifications () को कॉल करने की आवश्यकता है ताकि किसी भी रोटेशन घटना के होने से पहले वास्तविक रोटेशन हो सके।

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