कीबोर्ड के तेज दिखाई देने पर टेक्स्ट फील्ड को मूव करें


217

मैं iOS के साथ प्रोग्राम करने के लिए स्विफ्ट का उपयोग कर रहा हूं और इस कोड को स्थानांतरित करने के लिए उपयोग कर रहा हूं UITextField, लेकिन यह काम नहीं करता है। मैं फ़ंक्शन को keyboardWillShowसही ढंग से कॉल करता हूं , लेकिन टेक्स्टफील्ड हिलता नहीं है। मैं ऑटोलेयूट का उपयोग कर रहा हूं।

override func viewDidLoad() {
    super.viewDidLoad()
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillShow:"), name:UIKeyboardWillShowNotification, object: nil);
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillHide:"), name:UIKeyboardWillHideNotification, object: nil);
}

deinit {
    NSNotificationCenter.defaultCenter().removeObserver(self);
}

func keyboardWillShow(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
        //let contentInsets = UIEdgeInsets(top: 0, left: 0, bottom: keyboardSize.height, right: 0)

        var frame = self.ChatField.frame
        frame.origin.y = frame.origin.y - keyboardSize.height + 167
        self.chatField.frame = frame
        println("asdasd")
    }
}

2
प्रोजेक्ट फाइलों के साथ वॉकथ्रू
Dan Beaulieu

शायद डिनीट और व्यूडीडलॉड संतुलित नहीं हैं।
रिकार्डो

Apple के डॉक्स और व्यक्तिगत अनुभव दोनों के आधार पर। यहाँ TF को स्थानांतरित करने के लिए UIScrollView का उपयोग करके मेरा git रेपो है: github.com/29satnam/MoveTextFieldWhenKeyboardAppearsSwift
Codetard

जवाबों:


315

मौजूदा उत्तरों पर कुछ सुधार किए जाने हैं।

सबसे पहले UIKeyboardWillChangeFrameNotification शायद सबसे अच्छा नोटिफिकेशन है क्योंकि यह उन बदलावों को संभालता है जो सिर्फ दिखावे / छिपाने के लिए नहीं होते हैं बल्कि कीबोर्ड में बदलाव (भाषा, तीसरी पार्टी के कीबोर्ड आदि का उपयोग करने के कारण) और घुमाव भी होते हैं (लेकिन कीबोर्ड को इंगित करने के लिए नोट टिप्पणी छिपाई जानी चाहिए) हार्डवेयर कीबोर्ड कनेक्शन का समर्थन करने के लिए भी संभाला जा सकता है)।

दूसरे एनीमेशन मानकों को अधिसूचना से खींचा जा सकता है ताकि यह सुनिश्चित हो सके कि एनिमेशन ठीक से एक साथ हैं।

संभवतः इस कोड को थोड़ा और साफ करने के लिए विकल्प हैं, खासकर यदि आप शब्दकोश कोड को बल के साथ सहज हैं।

स्विफ्ट 3

class MyViewController: UIViewController {

// This constraint ties an element at zero points from the bottom layout guide
@IBOutlet var keyboardHeightLayoutConstraint: NSLayoutConstraint?

override func viewDidLoad() {
    super.viewDidLoad()
    // Note that SO highlighting makes the new selector syntax (#selector()) look
    // like a comment but it isn't one
    NotificationCenter.default.addObserver(self,
        selector: #selector(self.keyboardNotification(notification:)),
        name: NSNotification.Name.UIKeyboardWillChangeFrame,
        object: nil)
}

deinit {
    NotificationCenter.default.removeObserver(self)
}

@objc func keyboardNotification(notification: NSNotification) {
    if let userInfo = notification.userInfo {
        let endFrame = (userInfo[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue
        let endFrameY = endFrame.origin.y ?? 0
        let duration:TimeInterval = (userInfo[UIKeyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
        let animationCurveRawNSN = userInfo[UIKeyboardAnimationCurveUserInfoKey] as? NSNumber
        let animationCurveRaw = animationCurveRawNSN?.uintValue ?? UIViewAnimationOptions.curveEaseInOut.rawValue
        let animationCurve:UIViewAnimationOptions = UIViewAnimationOptions(rawValue: animationCurveRaw)
        if endFrameY >= UIScreen.main.bounds.size.height {
            self.keyboardHeightLayoutConstraint?.constant = 0.0
        } else {
            self.keyboardHeightLayoutConstraint?.constant = endFrame?.size.height ?? 0.0
        }
        UIView.animate(withDuration: duration,
                                   delay: TimeInterval(0),
                                   options: animationCurve,
                                   animations: { self.view.layoutIfNeeded() },
                                   completion: nil)
    }
}

(नीचे गैबॉक्स की भयानक टिप्पणी के अनुसार, सिकुड़ने के बजाय ऑफस्क्रीन एनिमेटिंग के लिए संपादित करने के लिए संपादित)

स्विफ्ट 5

class MyViewController: UIViewController {

// This constraint ties an element at zero points from the bottom layout guide
@IBOutlet var keyboardHeightLayoutConstraint: NSLayoutConstraint?

override func viewDidLoad() {
    super.viewDidLoad()
    // Note that SO highlighting makes the new selector syntax (#selector()) look
    // like a comment but it isn't one
    NotificationCenter.default.addObserver(self,
        selector: #selector(self.keyboardNotification(notification:)),
        name: UIResponder.keyboardWillChangeFrameNotification,
        object: nil)
}

deinit {
    NotificationCenter.default.removeObserver(self)
}

@objc func keyboardNotification(notification: NSNotification) {
    if let userInfo = notification.userInfo {
        let endFrame = (userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue
        let endFrameY = endFrame?.origin.y ?? 0
        let duration:TimeInterval = (userInfo[UIResponder.keyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
        let animationCurveRawNSN = userInfo[UIResponder.keyboardAnimationCurveUserInfoKey] as? NSNumber
        let animationCurveRaw = animationCurveRawNSN?.uintValue ?? UIView.AnimationOptions.curveEaseInOut.rawValue
        let animationCurve:UIView.AnimationOptions = UIView.AnimationOptions(rawValue: animationCurveRaw)
        if endFrameY >= UIScreen.main.bounds.size.height {
            self.keyboardHeightLayoutConstraint?.constant = 0.0
        } else {
            self.keyboardHeightLayoutConstraint?.constant = endFrame?.size.height ?? 0.0
        }
        UIView.animate(withDuration: duration,
                                   delay: TimeInterval(0),
                                   options: animationCurve,
                                   animations: { self.view.layoutIfNeeded() },
                                   completion: nil)
    }
}

1
@ जोसेफ्लॉर्ड अच्छा है। लेकिन मैंने पाया कि जब कीबोर्ड छुपा नहीं होता है तो यह काम नहीं करता endFrame?.size.heightहै। मुझे अंत फ्रेम के रूप में मिला है UIKeyboardFrameEndUserInfoKey = "NSRect: {{0, 1024}, {768, 264}}";। IOS 8.3 iPad सिम्युलेटर, पोर्ट्रेट पर दौड़ा। Xcode6.3 Beta4।
हुलंग

8
यदि कीबोर्ड छिपता नहीं है, तो इस कोड का उपयोग करने का प्रयास करें यदि endFrame? .origin.y> = UIScreen.mainScreen ()। bounds.size.height {self.keyboardHeightLayoutConstantint.constant = 0.0} और {self.keyboardHeightLayoutConstraintraconconconconstint.con/ = endFrame.size.height}
गेब्रियल

3
keyBoardHeightLayoutConstraint एक अवरोध है, जो कि इंटरफ़ेसब्यूअल परिभाषित किया गया है, जो उस दृश्य के तल को विवश करता है, जिसे आप नीचे की तरफ ले जाना चाहते हैं या नीचे की तरफ ले जाना चाहते हैं या व्यूहोलर के लिए मुख्य दृश्य के नीचे। निरंतर शुरू में शून्य पर सेट है और कीबोर्ड दिखाई देने या आकार बदलने पर कीबोर्ड के लिए जगह बनाने के लिए समायोजित किया जाएगा।
जोसेफ लॉर्ड

2
ध्यान दें कि .UIKeyboardWillChangeFrameहार्डवेयर कीबोर्ड कनेक्ट होने पर फायर नहीं करता है, भले ही iOS कीबोर्ड गायब हो जाए। आपको .UIKeyboardWillHideउस किनारे के मामले को पकड़ने के लिए भी निरीक्षण करने की आवश्यकता है ।
17

1
@ सुल्तान ठीक काम करता है .. मेरा मुद्दा यह है कि कीबर्ड की तुलना में थोड़ा अधिक हो रहा है। क्या कोई तरीका है जिससे हम इसे ठीक कर सकते हैं?
पावलोस

128

यदि आप ऑटो लेआउट का उपयोग कर रहे हैं, तो मुझे लगता है कि आपने सुपरव्यू बाधा के लिए निचला स्थान निर्धारित किया है । अगर ऐसा है, तो आपको बस बाधा के मूल्य को अपडेट करना होगा। यहाँ आप इसे थोड़ा एनीमेशन के साथ कैसे करते हैं।

func keyboardWasShown(notification: NSNotification) {
    let info = notification.userInfo!
    let keyboardFrame: CGRect = (info[UIKeyboardFrameEndUserInfoKey] as! NSValue).CGRectValue()

    UIView.animateWithDuration(0.1, animations: { () -> Void in
        self.bottomConstraint.constant = keyboardFrame.size.height + 20
    })
}

हार्डकोड 20 को केवल कीबोर्ड के ऊपर टेक्स्टफील्ड को पॉप करने के लिए जोड़ा जाता है। अन्यथा कीबोर्ड का टॉप मार्जिन और टेक्स्टफील्ड का निचला मार्जिन टच होता है।

जब कीबोर्ड को खारिज कर दिया जाता है, तो बाधा के मूल्य को उसके मूल में रीसेट करें।


1
क्या आप मुझे pls समझा सकते हैं कि मैं इसे कैसे परिभाषित करूं? धन्यवाद! मैं हमेशा स्टोरीबोर्ड पर सभी को नियंत्रित करता हूं
पेड्रो मैनफ्रेडी

4
बॉटम कॉन्ट्रास्टिंट वह नाम है जो मैंने बाधा को दिया था। मैंने कॉन्स्ट्रेंट का चयन किया, घसीटा और एक IBOutlet बनाया और उसे यह नाम दिया। आप बटन और पाठ फ़ील्ड जैसे अन्य UI तत्वों के साथ कर सकते हैं, ठीक वैसे ही आप IBOutlets को अवरोध के लिए बना सकते हैं।
इस्सरू

2
इस जवाब ने महान काम किया सिवाय एनीमेशन के मेरे लिए तुरंत हुआ। जांचें कि मैं बाधा को कैसे चेतन करूं? कैसे ठीक से चेतन करने के लिए।
एडम जॉन्स

2
@ vinbhai4u आपको UIKeyboardWillShowNotificationअधिसूचना के लिए पंजीकरण करना होगा । ओपी के प्रश्न में कोड को देखें।
इसुरु

8
@AdamJohns बाधा परिवर्तन को चेतन करने के लिए, स्थिरांक के बाहर स्थिरांक को अपडेट animateWithDurationकरें और कॉल करें self.view.layoutIfNeeded()
मैक्स

110

एक सरल उपाय यह है कि कीबोर्ड की ऊँचाई को स्थिर रखें।

override func viewDidLoad() {
   super.viewDidLoad()        
   NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillShow:"), name:UIKeyboardWillShowNotification, object: nil);
   NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillHide:"), name:UIKeyboardWillHideNotification, object: nil);
}

@objc func keyboardWillShow(sender: NSNotification) {
     self.view.frame.origin.y = -150 // Move view 150 points upward 
}

@objc func keyboardWillHide(sender: NSNotification) {
     self.view.frame.origin.y = 0 // Move view to original position  
}

स्विफ्ट 5:

NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow(sender:)), name: UIResponder.keyboardWillShowNotification, object: nil);

NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide(sender:)), name: UIResponder.keyboardWillHideNotification, object: nil);

4
मुझे यह सरल उपाय पसंद है। लेकिन मैंने एक कीबोर्ड जोड़ा है बूलियन क्योंकि मेरे पास एक से अधिक टेक्स्टफील्ड हैं। मैं केवल कीबोर्ड दिखा रहा हूं जबकि वह दिखा रहा है। धन्यवाद।
केन

2
दृश्य को स्थानांतरित करने के बजाय,
टेक्स्ट

1
यदि उपयोगकर्ता इनपुट भाषा को स्विच करता है, तो यह दृश्य का y मान घटाएगा।
जेफरी नियो

स्व.व्यू बदलने के बजाय मैंने self.myConstraint का मान लिया, यह काम करता है, लेकिन बात यह है कि दृश्य (जिस पर कसना लागू होता है) बढ़ता रहता है। किसी को भी इस मुद्दे का सामना करना पड़ा?
साशी

5
उपयोग self.view.frame.origin.y -= 150करने के self.view.frame.origin.y = -150बजाय और self.view.frame.origin.y += 150उपयोग के बजाय self.view.frame.origin.y = 0। यह दृश्य को हर बार 150 को एक नए क्षेत्र को छूने से रोकता है।
गनविन

43

टेक्स्टफ़ील्ड को संपादित करते समय अपना दृष्टिकोण बदलने के लिए, मैंने इसे लागू किया है,

विकल्प 1: - ** ** स्विफ्ट 5.0 और आईफोन एक्स में अपडेट, एक्सआर, एक्सएस और एक्सएस मैक्स अधिसूचना अधिसूचना का उपयोग करके स्थानांतरित करें

  • में इस अधिसूचना को पंजीकृत करें func viewWillAppear(_ animated: Bool)

  • इस अधिसूचना को निष्क्रिय करें func viewWillDisappear(_ animated: Bool)

नोट: - यदि आप डेरेगिस्टर नहीं करेंगे तो यह चाइल्ड क्लास से कॉल करेगा और दुर्घटनाग्रस्त होने का कारण होगा।

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    NotificationCenter.default.addObserver( self, selector: #selector(keyboardWillShow(notification:)), name:  UIResponder.keyboardWillShowNotification, object: nil )
}
override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    NotificationCenter.default.removeObserver(self, name: UIResponder.keyboardWillShowNotification, object: nil)
}

@objc func keyboardWillShow( notification: Notification) {
    if let keyboardFrame: NSValue = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue {
        var newHeight: CGFloat
        let duration:TimeInterval = (notification.userInfo![UIResponder.keyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
        let animationCurveRawNSN = notification.userInfo![UIResponder.keyboardAnimationCurveUserInfoKey] as? NSNumber
        let animationCurveRaw = animationCurveRawNSN?.uintValue ?? UIView.AnimationOptions.curveEaseInOut.rawValue
        let animationCurve:UIView.AnimationOptions = UIView.AnimationOptions(rawValue: animationCurveRaw)
        if #available(iOS 11.0, *) {
            newHeight = keyboardFrame.cgRectValue.height - self.view.safeAreaInsets.bottom
        } else {
            newHeight = keyboardFrame.cgRectValue.height
        }
        let keyboardHeight = newHeight  + 10 // **10 is bottom margin of View**  and **this newHeight will be keyboard height**
        UIView.animate(withDuration: duration,
                       delay: TimeInterval(0),
                       options: animationCurve,
                       animations: {
                        self.view.textViewBottomConstraint.constant = keyboardHeight **//Here you can manage your view constraints for animated show**
                        self.view.layoutIfNeeded() },
                       completion: nil)
    }
}

विकल्प 2: - इसका काम ठीक है

func textFieldDidBeginEditing(textField: UITextField) {
        self.animateViewMoving(up: true, moveValue: 100)
}
func textFieldDidEndEditing(textField: UITextField) {
        self.animateViewMoving(up: false, moveValue: 100)
}

func animateViewMoving (up:Bool, moveValue :CGFloat){
    var movementDuration:NSTimeInterval = 0.3
    var movement:CGFloat = ( up ? -moveValue : moveValue)
    UIView.beginAnimations( "animateView", context: nil)
    UIView.setAnimationBeginsFromCurrentState(true)
    UIView.setAnimationDuration(movementDuration )
    self.view.frame = CGRectOffset(self.view.frame, 0,  movement)
    UIView.commitAnimations()
}

मुझे यह उत्तर इस स्रोत UITextField की ओर से मिला जब स्विफ्ट में कीबोर्ड दिखाई देता है

स्विफ्ट 4 में ---

func textFieldDidBeginEditing(_ textField: UITextField) {
        animateViewMoving(up: true, moveValue: 100)
    }

    func textFieldDidEndEditing(_ textField: UITextField) {
        animateViewMoving(up: false, moveValue: 100)
    }
    func animateViewMoving (up:Bool, moveValue :CGFloat){
        let movementDuration:TimeInterval = 0.3
        let movement:CGFloat = ( up ? -moveValue : moveValue)
        UIView.beginAnimations( "animateView", context: nil)
        UIView.setAnimationBeginsFromCurrentState(true)
        UIView.setAnimationDuration(movementDuration ) 
        self.view.frame = self.view.frame.offsetBy(dx: 0, dy: movement)
        UIView.commitAnimations()
    }

1
@ Jogendra.Com, आपकी कड़ी मेहनत के लिए धन्यवाद। लेकिन, यह iPhone 5,4s और 6.But पर सबसे अच्छा काम करता है, मैं इसे iPhone 6plus और iPad (उच्चतर) पर कैसे अक्षम कर सकता हूं
Thiha Aung

यदि आप विकल्प 1 का उपयोग कर रहे हैं, तो कृपया एक बाधा IBOutlet जोड़ना सुनिश्चित करें। आप एक बाधा बनाएंगे जिसे आप ऑटो-लेआउट का उपयोग करके आकार बदलना चाहते हैं, फिर एक IBOutlet बनाने के लिए इसे व्यू कॉन्ट्रैक्टर में खींचें और ड्रॉप करें कि मैं इसे स्वयं के रूप में संदर्भित करता हूं। चेतन समारोह में आत्मनिर्भर। इसके अलावा यह कीबोर्ड को छिपाने पर आउटलेट को फिर से समायोजित नहीं करता है, मैंने संभाला है कि यह मूल मूल्य के लिए बाधा को रीसेट करके।
हम्माद तारिक

21

मुझे क्लीन स्विफ्ट कोड पसंद है। तो यहाँ एक सबसे कठोर कोड है जो मैं कीबोर्ड के साथ एक टेक्स्ट व्यू को ऊपर / नीचे ले जाने के लिए आ सकता हूँ। यह वर्तमान में एक iOS8 / 9 स्विफ्ट 2 उत्पादन ऐप में काम कर रहा है।

अद्यतन (मार्च २०१६): मैंने अपने पिछले कोड को यथासंभव अधिक कड़ा कर दिया है। इसके अलावा, यहां लोकप्रिय उत्तरों का एक समूह है जो कीबोर्ड की ऊंचाई और एनीमेशन मापदंडों को हार्डकोड करता है। इसके लिए कोई आवश्यकता नहीं है, यह उल्लेख करने के लिए नहीं कि इन उत्तरों में संख्या हमेशा मेरे 6s + iOS9 (226 की कीबोर्ड ऊंचाई, 0.25 की अवधि, और 7 के एनीमेशन वक्र) पर दिखाई देने वाले वास्तविक मूल्यों के अनुरूप नहीं है। किसी भी मामले में, सिस्टम से सीधे उन मूल्यों को प्राप्त करने के लिए यह लगभग कोई अतिरिक्त कोड नहीं है। निचे देखो।

override func viewDidLoad() {
    super.viewDidLoad()

    NSNotificationCenter.defaultCenter().addObserver(self, selector: "animateWithKeyboard:", name: UIKeyboardWillShowNotification, object: nil)
    NSNotificationCenter.defaultCenter().addObserver(self, selector: "animateWithKeyboard:", name: UIKeyboardWillHideNotification, object: nil)
}

func animateWithKeyboard(notification: NSNotification) {

    // Based on both Apple's docs and personal experience, 
    // I assume userInfo and its documented keys are available.
    // If you'd like, you can remove the forced unwrapping and add your own default values.

    let userInfo = notification.userInfo!
    let keyboardHeight = (userInfo[UIKeyboardFrameEndUserInfoKey] as! NSValue).CGRectValue().height
    let duration = userInfo[UIKeyboardAnimationDurationUserInfoKey] as! Double
    let curve = userInfo[UIKeyboardAnimationCurveUserInfoKey] as! UInt
    let moveUp = (notification.name == UIKeyboardWillShowNotification)

    // baseContraint is your Auto Layout constraint that pins the
    // text view to the bottom of the superview.

    baseConstraint.constant = moveUp ? -keyboardHeight : 0

    let options = UIViewAnimationOptions(rawValue: curve << 16)
    UIView.animateWithDuration(duration, delay: 0, options: options,
        animations: {
            self.view.layoutIfNeeded()
        },
        completion: nil
    )

}

नोट: इस कोड में सबसे अधिक टिप्पणी / सामान्य मामला शामिल है। हालांकि, अलग-अलग झुकाव और / या कस्टम कीबोर्ड को संभालने के लिए अधिक कोड की आवश्यकता हो सकती है यहां iOS कीबोर्ड के साथ काम करने पर एक गहन लेख है । यदि आपको प्रत्येक परिदृश्य को संभालने की आवश्यकता है, तो यह मदद कर सकता है।


लगता है कि स्विफ्ट 1.1 है और मुझे लगता है कि स्विफ्ट 1.2 में संकलन नहीं होगा क्योंकि यह asबल के कलाकारों के लिए उपयोग करता है । as!काम कर सकते हैं, लेकिन जैसा कि आप इस पृष्ठ पर कहीं और देख सकते हैं मैं बल जातियों से बचने और अपने आप को बल देने के लिए मजबूर करता हूं।
जोसेफ लॉर्ड

स्विफ्ट 1.2 में अब संकलन। और मैंने फिर से कोड में एक टिप्पणी जोड़ दी: मजबूर अलिखित। चीयर्स।
स्कूटर

उफ़। मेरा मतलब था स्विफ्ट 2.
स्कूटर्म

इस पर निर्भर करता है कि आपने अपना लिंक अप कैसे baseConstraintकिया, baseConstraint.constant = moveUp ? keyboardHeight : 0इसके बजाय यह हो सकता है baseConstraint.constant = moveUp ? -keyboardHeight : 0
लाइमफिनिटी

15

संपादित करें : मैं एक आसान और क्लीनर समाधान सुझाता हूं। बस नीचे के स्थान को कसने की श्रेणी को KeyboardLayoutConstraint में बदलें । यह स्वचालित रूप से कीबोर्ड की ऊंचाई तक फैल जाएगा।


यह @JosephLord के उत्तर का एक उन्नत संस्करण है।

जैसा कि iOS 8.3 iPad सिम्युलेटर, पोर्ट्रेट पर परीक्षण किया गया है। Xcode6.3 Beta4, मैंने पाया कि उसका जवाब तब काम नहीं करता जब कीबोर्ड छुपा होता UIKeyboardFrameEndUserInfoKeyहै "NSRect: {{0, 1024}, {768, 264}}";। कद कभी नहीं है 0

यह पारंपरिक का उपयोग करने के लिए वापस जाता है UIKeyboardWillShowNotificationऔर UIKeyboardWillHideNotificationबेहतर बताता है कि कीबोर्ड अंत फ्रेम की ऊंचाई पर निर्भर होने के बजाय छुपा रहा है। UIKeyboardWillShowNotificationयह भी भेजा जाता है जब कीबोर्ड फ्रेम बदल जाता है तो इसे सभी उपयोग मामलों को कवर करना चाहिए

    // You have to set this up in storyboard first!. 
    // It's a vertical spacing constraint between view and bottom of superview.
    @IBOutlet weak var bottomSpacingConstraint: NSLayoutConstraint! 

    override func viewDidLoad() {
        super.viewDidLoad()

        NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardNotification:"), name:UIKeyboardWillShowNotification, object: nil);
        NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardNotification:"), name:UIKeyboardWillHideNotification, object: nil);
    }

    deinit {
        NSNotificationCenter.defaultCenter().removeObserver(self)
    }

    func keyboardNotification(notification: NSNotification) {

        let isShowing = notification.name == UIKeyboardWillShowNotification

        if let userInfo = notification.userInfo {
            let endFrame = (userInfo[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue()
            let endFrameHeight = endFrame?.size.height ?? 0.0
            let duration:NSTimeInterval = (userInfo[UIKeyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
            let animationCurveRawNSN = userInfo[UIKeyboardAnimationCurveUserInfoKey] as? NSNumber
            let animationCurveRaw = animationCurveRawNSN?.unsignedLongValue ?? UIViewAnimationOptions.CurveEaseInOut.rawValue
            let animationCurve:UIViewAnimationOptions = UIViewAnimationOptions(rawValue: animationCurveRaw)
            self.bottomSpacingConstraint?.constant = isShowing ? endFrameHeight : 0.0
            UIView.animateWithDuration(duration,
                delay: NSTimeInterval(0),
                options: animationCurve,
                animations: { self.view.layoutIfNeeded() },
                completion: nil)
        }
    }

क्या आप कृपया अपना संपादन समझा सकते हैं? मैं इसे काम नहीं कर सका। मैं नीचे एक बटन के साथ एक UIScrollView है। मैंने नीचे के मार्जिन मार्जिन अवरोध पर कक्षा का निपटान किया।
schw4ndi

@ schw4ndi आपके निचले हिस्से को किन विचारों से जोड़ा गया है? यह स्क्रोलव्यू के निचले हिस्से को उस स्क्रॉलव्यू के सुपरवाइवे के नीचे से जोड़ना चाहिए।
बजे हुलंग

ओह धन्यवाद, मेरे पास बटन और
स्क्रॉल दृश्य के

9

मैं स्विफ्ट 4 के साथ काम कर रहा हूँ और मैं इस मुद्दे को हल कर रहा हूँ बिना किसी अतिरिक्त नीचे की कमी के उपयोग के कारण मेरा कोड यहाँ है। क्या वास्तव में मेरे मामले पर काम हो रहा है

1) किए गए लोड में अधिसूचना पर्यवेक्षक जोड़ें

override func viewDidLoad() {
        super.viewDidLoad()
        setupManager()
        // Do any additional setup after loading the view.
        NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
    }

2) नोटिफिकेशन ऑब्जर्वर जैसे निकालें

deinit {
        NotificationCenter.default.removeObserver(self)
    }

3) कीबोर्ड शो / छिपाने के तरीके जोड़ें

 @objc func keyboardWillShow(notification: NSNotification) {
            if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
                UIView.animate(withDuration: 0.1, animations: { () -> Void in
                    self.view.frame.origin.y -= keyboardSize.height
                    self.view.layoutIfNeeded()
                })
            }
        }

@objc func keyboardWillHide(notification: NSNotification) {
        if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
            UIView.animate(withDuration: 0.1, animations: { () -> Void in
                self.view.frame.origin.y += keyboardSize.height
                self.view.layoutIfNeeded()
            })
        }
    }

4) टेक्सफाइल्ड डेलीगेट जोड़ें और टचबेजन मेथड्स जोड़ें। कीबोर्ड को छुपाने के लिए .usefull जब स्क्रीन पर टेक्स्टफिल्ड के बाहर टच करें

override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        view.endEditing(true)

    }

जरूरत हैUIKeyboardFrameEndUserInfoKey
माइक्रो

1
NSNotification.Name.UIKeyboardWillShow को UIResponder.keyboardWillShowNotificationभी नाम दिया UIKeyboardFrameBeginUserInfoKey गया हैUIResponder.keyboardFrameBeginUserInfoKey
smj

7

यह @JosephLord और @ Hlung के उत्तर का एक उन्नत संस्करण है। यह लागू हो सकता है कि आपके पास टैब्बर है या नहीं। और यह पूरी तरह से दृश्य को बहाल करेगा जो कीबोर्ड द्वारा मूल स्थिति में ले जाया गया है।

// You have to set this up in storyboard first!. 
// It's a vertical spacing constraint between view and bottom of superview.
@IBOutlet weak var bottomSpacingConstraint: NSLayoutConstraint! 

override func viewDidLoad() {
        super.viewDidLoad()            

        //    Receive(Get) Notification
        NSNotificationCenter.defaultCenter().addObserver(self, selector: "keyboardNotification:", name: UIKeyboardWillShowNotification, object: nil)
        NSNotificationCenter.defaultCenter().addObserver(self, selector: "keyboardNotification:", name: UIKeyboardWillHideNotification, object: nil)


        self.originalConstraint = self.keyboardHeightLayoutConstraint?.constant //for original coordinate.
}

func keyboardNotification(notification: NSNotification) {
        let isShowing = notification.name == UIKeyboardWillShowNotification

        var tabbarHeight: CGFloat = 0
        if self.tabBarController? != nil {
            tabbarHeight = self.tabBarController!.tabBar.frame.height
        }
        if let userInfo = notification.userInfo {
            let endFrame = (userInfo[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue()
            let duration:NSTimeInterval = (userInfo[UIKeyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
            let animationCurveRawNSN = userInfo[UIKeyboardAnimationCurveUserInfoKey] as? NSNumber
            let animationCurveRaw = animationCurveRawNSN?.unsignedLongValue ?? UIViewAnimationOptions.CurveEaseInOut.rawValue
            let animationCurve:UIViewAnimationOptions = UIViewAnimationOptions(rawValue: animationCurveRaw)
            self.keyboardHeightLayoutConstraint?.constant = isShowing ? (endFrame!.size.height - tabbarHeight) : self.originalConstraint!
            UIView.animateWithDuration(duration,
                delay: NSTimeInterval(0),
                options: animationCurve,
                animations: { self.view.layoutIfNeeded() },
                completion: nil)
        }
}

6

सबसे आसान तरीका है कि किसी भी कोड की आवश्यकता नहीं है:

  1. यदि आप पहले से ही स्प्रिंग एनीमेशन फ्रेमवर्क का उपयोग नहीं कर रहे हैं, तो KeyboardLayoutConstraint.swift डाउनलोड करें और अपनी परियोजना में फ़ाइल जोड़ें (खींचें और छोड़ें)।
  2. अपने स्टोरीबोर्ड में, ऑब्जेक्ट / दृश्य / टेक्स्टफ़ील्ड के लिए एक निचला अवरोध बनाएं, बाधा का चयन करें (पहचान पर डबल-क्लिक करें) और पहचान निरीक्षक में, NSLayoutConstraint से KeyboardLayConConstraint तक अपनी कक्षा बदलें।
  3. किया हुआ!

ऑब्जेक्ट कीबोर्ड के साथ सिंक में आटो-मूव करेगा।


2
महान समाधान! लेकिन आपको सुरक्षित क्षेत्र की आवश्यकता है। बाधा पर पहली वस्तु के रूप में देखें। (दूसरी वस्तु होने पर मेरे लिए काम नहीं किया गया)। और यह निरंतर सेट 0 के साथ सबसे अच्छा काम करता है क्योंकि यह निरंतरता को बनाए रखता है और इसे समायोजित करता है, न कि केवल क्षेत्र और कीबोर्ड को दिखाने के लिए इसे बहुत दूर ले जाने के बजाय।
मिथालैंडिया

क्या आपके पास KeyboardLayoutConstraint स्विफ्ट 4 संस्करण है?
jeet.chanchawat

6

मैंने कीबोर्ड उपस्थिति / गायब होने से निपटने के लिए एक स्विफ्ट 3 प्रोटोकॉल बनाया

import UIKit

protocol KeyboardHandler: class {

var bottomConstraint: NSLayoutConstraint! { get set }

    func keyboardWillShow(_ notification: Notification)
    func keyboardWillHide(_ notification: Notification)
    func startObservingKeyboardChanges()
    func stopObservingKeyboardChanges()
}


extension KeyboardHandler where Self: UIViewController {

    func startObservingKeyboardChanges() {

        // NotificationCenter observers
        NotificationCenter.default.addObserver(forName: NSNotification.Name.UIKeyboardWillShow, object: nil, queue: nil) { [weak self] notification in
          self?.keyboardWillShow(notification)
        }

        // Deal with rotations
        NotificationCenter.default.addObserver(forName: NSNotification.Name.UIKeyboardWillChangeFrame, object: nil, queue: nil) { [weak self] notification in
          self?.keyboardWillShow(notification)
        }

        // Deal with keyboard change (emoji, numerical, etc.)
        NotificationCenter.default.addObserver(forName: NSNotification.Name.UITextInputCurrentInputModeDidChange, object: nil, queue: nil) { [weak self] notification in
          self?.keyboardWillShow(notification)
        }

        NotificationCenter.default.addObserver(forName: NSNotification.Name.UIKeyboardWillHide, object: nil, queue: nil) { [weak self] notification in
          self?.keyboardWillHide(notification)
        }
    }


    func keyboardWillShow(_ notification: Notification) {

      let verticalPadding: CGFloat = 20 // Padding between the bottom of the view and the top of the keyboard

      guard let value = notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue else { return }
      let keyboardHeight = value.cgRectValue.height

      // Here you could have more complex rules, like checking if the textField currently selected is actually covered by the keyboard, but that's out of this scope.
      self.bottomConstraint.constant = keyboardHeight + verticalPadding

      UIView.animate(withDuration: 0.1, animations: { () -> Void in
          self.view.layoutIfNeeded()
      })
  }


  func keyboardWillHide(_ notification: Notification) {
      self.bottomConstraint.constant = 0

      UIView.animate(withDuration: 0.1, animations: { () -> Void in
          self.view.layoutIfNeeded()
      })
  }


  func stopObservingKeyboardChanges() {
      NotificationCenter.default.removeObserver(self)
  }

}

फिर, इसे UIViewController में कार्यान्वित करने के लिए, निम्न कार्य करें:

  • इस प्रोटोकॉल के अनुसार viewController के अनुरूप होने दें:

    class FormMailVC: UIViewControlle, KeyboardHandler {
  • दृश्य में कीबोर्ड परिवर्तन देखना शुरू करें

    // MARK: - View controller life cycle
    override func viewWillAppear(_ animated: Bool) {
      super.viewWillAppear(animated)
      startObservingKeyboardChanges()
    }
  • दृश्य में कीबोर्ड परिवर्तन देखना बंद करें

    override func viewWillDisappear(_ animated: Bool) {
      super.viewWillDisappear(animated)
      stopObservingKeyboardChanges()
    }
  • स्टोरीबोर्ड से निचले अवरोध के लिए एक IBOutlet बनाएं:

    // NSLayoutConstraints
    @IBOutlet weak var bottomConstraint: NSLayoutConstraint!

    (मेरा सुझाव है कि आपके सभी यूआई एक "contentView" के अंदर एम्बेडेड हैं, और इस संपत्ति को इस सामग्री से नीचे की ओर जोड़ने के लिए नीचे दिए गए लेआउट गाइड में बाधा डालते हैं) सामग्री देखें नीचे की बाधा

  • शीर्ष बाधा की बाधा प्राथमिकता 250 (कम) में बदलें

सामग्री दृश्य शीर्ष बाधा

जब कीबोर्ड दिखाई देता है तो यह पूरी सामग्री को ऊपर की ओर स्लाइड करने देता है। प्राथमिकताएं साक्षात्कार में किसी भी अन्य बाधा से कम होनी चाहिए, जिसमें सामग्री की प्राथमिकताएं / सामग्री संपीड़न प्रतिरोध प्राथमिकताएं शामिल हैं।

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

आपको इसके लिए "बराबर से अधिक" अवरोध जोड़ना पड़ सकता है: "बराबर से अधिक" बाधा

और यहाँ तुम जाओ! कीबोर्ड के बिना

कीबोर्ड के साथ


यह काम किया है अगर आप "संबंध = समान" भी, चेतावनी के बिना डाल दिया।
वाल्टोनी बोवेन्टुरा

यदि आप एक समान संबंध रखते हैं, तो यह केवल विशिष्ट स्थितियों में काम कर सकता है। दूसरों में आपके पास एक ऑटो लेआउट असंगति चेतावनी हो सकती है। यह आपके स्वयं के लेआउट पर निर्भर करता है। इसलिए मैंने कहा "आपको करना पड़ सकता है"।
फ्रेडरिक एडा

Ok Frédéric, ने सहमति व्यक्त की। एक अच्छा समाधान था!
वाल्टोनी बोवेन्टुरा

लापताimport UIKit
मिरको

6

ऐसे सरल UIViewController विस्तार का उपयोग किया जा सकता है

//MARK: - Observers
extension UIViewController {

    func addObserverForNotification(notificationName: String, actionBlock: (NSNotification) -> Void) {
        NSNotificationCenter.defaultCenter().addObserverForName(notificationName, object: nil, queue: NSOperationQueue.mainQueue(), usingBlock: actionBlock)
    }

    func removeObserver(observer: AnyObject, notificationName: String) {
        NSNotificationCenter.defaultCenter().removeObserver(observer, name: notificationName, object: nil)
    }
}

//MARK: - Keyboard observers
extension UIViewController {

    typealias KeyboardHeightClosure = (CGFloat) -> ()

    func addKeyboardChangeFrameObserver(willShow willShowClosure: KeyboardHeightClosure?,
        willHide willHideClosure: KeyboardHeightClosure?) {
            NSNotificationCenter.defaultCenter().addObserverForName(UIKeyboardWillChangeFrameNotification,
                object: nil, queue: NSOperationQueue.mainQueue(), usingBlock: { [weak self](notification) in
                    if let userInfo = notification.userInfo,
                        let frame = (userInfo[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue(),
                        let duration = userInfo[UIKeyboardAnimationDurationUserInfoKey] as? Double,
                        let c = userInfo[UIKeyboardAnimationCurveUserInfoKey] as? UInt,
                        let kFrame = self?.view.convertRect(frame, fromView: nil),
                        let kBounds = self?.view.bounds {

                            let animationType = UIViewAnimationOptions(rawValue: c)
                            let kHeight = kFrame.size.height
                            UIView.animateWithDuration(duration, delay: 0, options: animationType, animations: {
                                if CGRectIntersectsRect(kBounds, kFrame) { // keyboard will be shown
                                    willShowClosure?(kHeight)
                                } else { // keyboard will be hidden
                                    willHideClosure?(kHeight)
                                }
                                }, completion: nil)
                    } else {
                            print("Invalid conditions for UIKeyboardWillChangeFrameNotification")
                    }
            })
    }

    func removeKeyboardObserver() {
        removeObserver(self, notificationName: UIKeyboardWillChangeFrameNotification)
    }
}

उपयोग का उदाहरण

override func viewWillDisappear(animated: Bool) {
        super.viewWillDisappear(animated)

        removeKeyboardObserver()
    }

override func viewWillAppear(animated: Bool) {
    super.viewWillAppear(animated)

    addKeyboardChangeFrameObserver(willShow: { [weak self](height) in
        //Update constraints here
        self?.view.setNeedsUpdateConstraints()
        }, willHide: { [weak self](height) in
        //Reset constraints here
        self?.view.setNeedsUpdateConstraints()
    })
}

स्विफ्ट 4 समाधान

//MARK: - Observers
extension UIViewController {

  func addObserverForNotification(_ notificationName: Notification.Name, actionBlock: @escaping (Notification) -> Void) {
    NotificationCenter.default.addObserver(forName: notificationName, object: nil, queue: OperationQueue.main, using: actionBlock)
  }

  func removeObserver(_ observer: AnyObject, notificationName: Notification.Name) {
    NotificationCenter.default.removeObserver(observer, name: notificationName, object: nil)
  }
}

//MARK: - Keyboard handling
extension UIViewController {

  typealias KeyboardHeightClosure = (CGFloat) -> ()

  func addKeyboardChangeFrameObserver(willShow willShowClosure: KeyboardHeightClosure?,
                                      willHide willHideClosure: KeyboardHeightClosure?) {
    NotificationCenter.default.addObserver(forName: NSNotification.Name.UIKeyboardWillChangeFrame,
                                           object: nil, queue: OperationQueue.main, using: { [weak self](notification) in
                                            if let userInfo = notification.userInfo,
                                              let frame = (userInfo[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue,
                                              let duration = userInfo[UIKeyboardAnimationDurationUserInfoKey] as? Double,
                                              let c = userInfo[UIKeyboardAnimationCurveUserInfoKey] as? UInt,
                                              let kFrame = self?.view.convert(frame, from: nil),
                                              let kBounds = self?.view.bounds {

                                              let animationType = UIViewAnimationOptions(rawValue: c)
                                              let kHeight = kFrame.size.height
                                              UIView.animate(withDuration: duration, delay: 0, options: animationType, animations: {
                                                if kBounds.intersects(kFrame) { // keyboard will be shown
                                                  willShowClosure?(kHeight)
                                                } else { // keyboard will be hidden
                                                  willHideClosure?(kHeight)
                                                }
                                              }, completion: nil)
                                            } else {
                                              print("Invalid conditions for UIKeyboardWillChangeFrameNotification")
                                            }
    })
  }

  func removeKeyboardObserver() {
    removeObserver(self, notificationName: NSNotification.Name.UIKeyboardWillChangeFrame)
  }
}

स्विफ्ट 4.2

//MARK: - Keyboard handling
extension UIViewController {

    func addObserverForNotification(_ notificationName: Notification.Name, actionBlock: @escaping (Notification) -> Void) {
        NotificationCenter.default.addObserver(forName: notificationName, object: nil, queue: OperationQueue.main, using: actionBlock)
    }

    func removeObserver(_ observer: AnyObject, notificationName: Notification.Name) {
        NotificationCenter.default.removeObserver(observer, name: notificationName, object: nil)
    }

    typealias KeyboardHeightClosure = (CGFloat) -> ()

    func removeKeyboardObserver() {
        removeObserver(self, notificationName: UIResponder.keyboardWillChangeFrameNotification)
    }

    func addKeyboardChangeFrameObserver(willShow willShowClosure: KeyboardHeightClosure?,
                                        willHide willHideClosure: KeyboardHeightClosure?) {
        NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillChangeFrameNotification,
                                               object: nil, queue: OperationQueue.main, using: { [weak self](notification) in
                                                if let userInfo = notification.userInfo,
                                                    let frame = (userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue,
                                                    let duration = userInfo[UIResponder.keyboardAnimationDurationUserInfoKey] as? Double,
                                                    let c = userInfo[UIResponder.keyboardAnimationCurveUserInfoKey] as? UInt,
                                                    let kFrame = self?.view.convert(frame, from: nil),
                                                    let kBounds = self?.view.bounds {

                                                    let animationType = UIView.AnimationOptions(rawValue: c)
                                                    let kHeight = kFrame.size.height
                                                    UIView.animate(withDuration: duration, delay: 0, options: animationType, animations: {
                                                        if kBounds.intersects(kFrame) { // keyboard will be shown
                                                            willShowClosure?(kHeight)
                                                        } else { // keyboard will be hidden
                                                            willHideClosure?(kHeight)
                                                        }
                                                    }, completion: nil)
                                                } else {
                                                    print("Invalid conditions for UIKeyboardWillChangeFrameNotification")
                                                }
        })
    }
}

2
अन्य समाधानों की तुलना में बहुत अधिक "स्विफ्ट" / सब कुछ फिर से लिखने के बिना हर नियंत्रक में महान / पुन: प्रयोज्य काम करता है -> निश्चित रूप से सबसे अच्छा एक यहाँ :)
टिब्बा

मैंने कोशिश की लेकिन कोई मौका नहीं, क्या UIScrollView की जरूरत है या क्या?
erdemgc

@erdemgc आपने उपयोग का उदाहरण देखा? आप सभी की जरूरत है बस UIViewControlller + addKeyboardChangeFrameObserver है और फिर इसे हटाने के लिए मत भूलना
ale_stro

removeKeyboardObserver()यहां की विधि वास्तव में पर्यवेक्षक को नहीं हटाती है। यदि आप इसे कॉल नहीं करते हैं, तो आप Invalid conditions for UIKeyboardWillChangeFrameNotificationऐड मेथड से कंसोल में देखेंगे । यदि आप इसे कहते हैं, तो आपको वही त्रुटि दिखाई देगी, जिसका अर्थ है कि पर्यवेक्षक को हटाया नहीं गया है। दस्तावेज़ में कहा गया है "टिप्पणियों को अपंजीकृत करने के लिए, आप इस विधि द्वारा लौटाए गए ऑब्जेक्ट को पास करते हैं removeObserver(_:)।" इसलिए आप इसके बजाय जो करते हैं, उस विधि द्वारा लौटाए गए ऑब्जेक्ट को सहेजते हैं, फिर उसे पास करें जब आप पर्यवेक्षक को हटाना चाहते हैं।
-अनह होंग

दरअसल, एक बार स्क्रोलव्यू लोड हो जाने के बाद, बाउंड को एक मान दिया जाता है और आप यह पता नहीं लगा सकते हैं कि यदि कीबोर्ड फ्रेम के साथ बाउंड हो जाता है तो क्या कीबोर्ड छिपा होगा।
जेम्स किम

5

आप इस लाइब्रेरी का उपयोग कर सकते हैं और appDidFinishedLaunching और u में कोड की सिर्फ एक लाइन कर रहे हैं ..

func application(application: UIApplication,didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {

    IQKeyboardManager.sharedManager().enable = true
    return true
}

IQKeyboardManager - जब भी कीबोर्ड लिंक दिखाई दे तो समायोजित करें - https://github.com/hackiftekhar/IQKeyboardManager


4
struct MoveKeyboard {
    static let KEYBOARD_ANIMATION_DURATION : CGFloat = 0.3
    static let MINIMUM_SCROLL_FRACTION : CGFloat = 0.2;
    static let MAXIMUM_SCROLL_FRACTION : CGFloat = 0.8;
    static let PORTRAIT_KEYBOARD_HEIGHT : CGFloat = 216;
    static let LANDSCAPE_KEYBOARD_HEIGHT : CGFloat = 162;
}


  func textFieldDidBeginEditing(textField: UITextField) {
    let textFieldRect : CGRect = self.view.window!.convertRect(textField.bounds, fromView: textField)
    let viewRect : CGRect = self.view.window!.convertRect(self.view.bounds, fromView: self.view)

    let midline : CGFloat = textFieldRect.origin.y + 0.5 * textFieldRect.size.height
    let numerator : CGFloat = midline - viewRect.origin.y - MoveKeyboard.MINIMUM_SCROLL_FRACTION * viewRect.size.height
    let denominator : CGFloat = (MoveKeyboard.MAXIMUM_SCROLL_FRACTION - MoveKeyboard.MINIMUM_SCROLL_FRACTION) * viewRect.size.height
    var heightFraction : CGFloat = numerator / denominator

    if heightFraction < 0.0 {
        heightFraction = 0.0
    } else if heightFraction > 1.0 {
        heightFraction = 1.0
    }

    let orientation : UIInterfaceOrientation = UIApplication.sharedApplication().statusBarOrientation
    if (orientation == UIInterfaceOrientation.Portrait || orientation == UIInterfaceOrientation.PortraitUpsideDown) {
        animateDistance = floor(MoveKeyboard.PORTRAIT_KEYBOARD_HEIGHT * heightFraction)
    } else {
        animateDistance = floor(MoveKeyboard.LANDSCAPE_KEYBOARD_HEIGHT * heightFraction)
    }

    var viewFrame : CGRect = self.view.frame
    viewFrame.origin.y -= animateDistance

    UIView.beginAnimations(nil, context: nil)
    UIView.setAnimationBeginsFromCurrentState(true)
    UIView.setAnimationDuration(NSTimeInterval(MoveKeyboard.KEYBOARD_ANIMATION_DURATION))

    self.view.frame = viewFrame

    UIView.commitAnimations()
}


func textFieldDidEndEditing(textField: UITextField) {
    var viewFrame : CGRect = self.view.frame
    viewFrame.origin.y += animateDistance

    UIView.beginAnimations(nil, context: nil)
    UIView.setAnimationBeginsFromCurrentState(true)

    UIView.setAnimationDuration(NSTimeInterval(MoveKeyboard.KEYBOARD_ANIMATION_DURATION))

    self.view.frame = viewFrame

    UIView.commitAnimations()

}

और अंत में जब से हम प्रतिनिधियों के तरीकों का उपयोग कर रहे हैं

func textFieldShouldReturn(textField: UITextField) -> Bool {
        textField.resignFirstResponder()
        return true
    }

उद्देश्य- c http://www.cocoawithlove.com/2008/10/sliding-uitextfields-around-to-avoid.html का उपयोग करने से हटा दिया गया


इस समाधान ने मेरे लिए काम किया, हालांकि मुझे कुछ अतिरिक्त काम करना था: एक से var animateDistance: CGFloat!अधिक की घोषणा करें जब उपयोगकर्ता ने कीबोर्ड कीबोर्ड दबाया, तो इसके लिए मुझे UIKeyboardWillHideNotification को संभालना पड़ा।
रुवतवन

4

एक अन्य समाधान जो ऑटोलैयट, बाधाओं या किसी भी आउटलेट पर निर्भर नहीं करता है। आपको एक स्क्रॉलव्यू में अपने क्षेत्र की आवश्यकता है।

override func viewDidLoad() {
    super.viewDidLoad()

    NSNotificationCenter.defaultCenter().addObserver(self, selector: "makeSpaceForKeyboard:", name: UIKeyboardWillShowNotification, object: nil)
    NSNotificationCenter.defaultCenter().addObserver(self, selector: "makeSpaceForKeyboard:", name: UIKeyboardWillHideNotification, object: nil)
}

func makeSpaceForKeyboard(notification: NSNotification) {
    let info = notification.userInfo!
    let keyboardHeight:CGFloat = (info[UIKeyboardFrameEndUserInfoKey] as! NSValue).CGRectValue().size.height
    let duration:Double = info[UIKeyboardAnimationDurationUserInfoKey] as! Double

    if notification.name == UIKeyboardWillShowNotification {
        UIView.animateWithDuration(duration, animations: { () -> Void in
            var frame = self.view.frame
            frame.size.height = frame.size.height - keyboardHeight
            self.view.frame = frame
        })
    } else {
        UIView.animateWithDuration(duration, animations: { () -> Void in
            var frame = self.view.frame
            frame.size.height = frame.size.height + keyboardHeight
            self.view.frame = frame
        })
    }

}

1
यह UIKeyboardWillShowNotificationकॉल करने के बाद काली स्क्रीन दिखा रहा है ।
सचिन कुमारम

4

यहाँ स्विफ्ट 2.2 के समाधान के लिए मेरा संस्करण है:

कीबोर्ड शो / छिपाएं अधिसूचनाओं के लिए पहले पंजीकरण करें

NSNotificationCenter.defaultCenter().addObserver(self,
                                                 selector: #selector(MessageThreadVC.keyboardWillShow(_:)),
                                                 name: UIKeyboardWillShowNotification,
                                                 object: nil)
NSNotificationCenter.defaultCenter().addObserver(self,
                                                 selector: #selector(MessageThreadVC.keyboardWillHide(_:)),
                                                 name: UIKeyboardWillHideNotification,
                                                 object: nil)

फिर उन सूचनाओं के लिए तरीकों में मुख्य दृश्य को ऊपर या नीचे ले जाते हैं

func keyboardWillShow(sender: NSNotification) {
if let keyboardSize = (sender.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue() {
  self.view.frame.origin.y = -keyboardSize.height
  }
}

func keyboardWillHide(sender: NSNotification) {
self.view.frame.origin.y = 0
}

ट्रिक "कीबोर्ड विल्सशो" भाग में है जिसे हर बार कॉल मिलता है "क्विक टाइप सुझाव बार" का विस्तार या पतन होता है। फिर हम हमेशा मुख्य दृश्य के y समन्वय को निर्धारित करते हैं जो कुल कीबोर्ड ऊंचाई के नकारात्मक मूल्य के बराबर होता है ("क्विक टाइप बार" भाग के बिना)।

अंत में पर्यवेक्षकों को हटाने के लिए मत भूलना

deinit {
NSNotificationCenter.defaultCenter().removeObserver(self)
}

3

निम्नलिखित एक सरल समाधान है, जिससे टेक्स्ट फ़ील्ड में नीचे लेआउट गाइड के लिए इसे बांधने में बाधा होती है। यह बस कीबोर्ड की ऊंचाई को बाधा के स्थिरांक से जोड़ता है।

// This constraint ties the text field to the bottom layout guide
@IBOutlet var textFieldToBottomLayoutGuideConstraint: NSLayoutConstraint!

override func viewDidLoad() {
    super.viewDidLoad()

    NSNotificationCenter.defaultCenter().addObserver(self, selector: "keyboardWillShow:", name:UIKeyboardWillShowNotification, object: nil);
    NSNotificationCenter.defaultCenter().addObserver(self, selector: "keyboardWillHide:", name:UIKeyboardWillHideNotification, object: nil);
}

func keyboardWillShow(sender: NSNotification) {
    if let keyboardSize = (sender.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
        self.textFieldToBottomLayoutGuideConstraint?.constant += keyboardSize.height
    }
}

func keyboardWillHide(sender: NSNotification) {
    if let keyboardSize = (sender.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
        self.textFieldToBottomLayoutGuideConstraint?.constant -= keyboardSize.height
    }
}

3

खैर, मुझे लगता है कि मुझे बहुत देर हो सकती है लेकिन मुझे साकिब के जवाब का एक और सरल संस्करण मिला। मैं बाधाओं के साथ Autolayout का उपयोग कर रहा हूं। मेरे पास उपयोगकर्ता नाम और पासवर्ड फ़ील्ड के साथ एक अन्य मुख्य दृश्य के अंदर एक छोटा सा दृश्य है। दृश्य के y निर्देशांक को बदलने के बजाय मैं एक चर में मूल अवरोध मान को सहेज रहा हूं और बाधा के स्थिरांक को कुछ मान में बदल रहा हूं और फिर कीबोर्ड के खारिज होने के बाद, मैं बाधा को मूल में स्थापित कर रहा हूं। इस तरह यह उस समस्या से बचा जाता है, जो साकिब के उत्तर में है, (दृश्य आगे बढ़ता रहता है और रुकता नहीं है)। नीचे मेरा कोड है ...

override func viewDidLoad() {
    super.viewDidLoad()
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillShow:"), name:UIKeyboardWillShowNotification, object: nil);
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillHide:"), name:UIKeyboardWillHideNotification, object: nil);
    self.originalConstraint = self.centerYConstraint.constant
  }

  func keyboardWillShow(sender: NSNotification) {
    self.centerYConstraint.constant += 30
  }

  func keyboardWillHide(sender: NSNotification) {
    self.centerYConstraint.constant = self.originalConstraint
  }

इनरबोर्ड के अंदर कीबोर्ड विधि की स्थिति की जाँच करें यदि self.centerYConstraint.constant == self.originalCenterYConstraint है तो इस स्थिति के बीच कोड की एक पंक्ति है। OriginalCenterYContraint CenterYContraint का मूल मूल्य है कि मैं viewdidload में संग्रहीत कर रहा हूं। इसने मेरे लिए काम किया।
शशि

3

स्विफ्ट 4.x उत्तर, @ जोसेफ लॉर्ड और @ इस्ुरु से उत्तर विलय। bottomConstraintउस दृश्य के निचले अवरोध का प्रतिनिधित्व करता है जिसे आप घुमाने में रुचि रखते हैं।

override func viewDidLoad() {
    // Call super
    super.viewDidLoad()

    // Subscribe to keyboard notifications
    NotificationCenter.default.addObserver(self,
                                           selector: #selector(keyboardNotification(notification:)),
                                           name: UIResponder.keyboardWillChangeFrameNotification,
                                           object: nil)        
}


deinit {
    NotificationCenter.default.removeObserver(self)
}


@objc func keyboardNotification(notification: NSNotification) {
    if let userInfo = notification.userInfo {
        // Get keyboard frame
        let keyboardFrame = (userInfo[UIResponder.keyboardFrameEndUserInfoKey] as! NSValue).cgRectValue

        // Set new bottom constraint constant
        let bottomConstraintConstant = keyboardFrame.origin.y >= UIScreen.main.bounds.size.height ? 0.0 : keyboardFrame.size.height

        // Set animation properties
        let duration = (userInfo[UIResponder.keyboardAnimationDurationUserInfoKey] as? NSNumber)?.doubleValue ?? 0
        let animationCurveRawNSN = userInfo[UIResponder.keyboardAnimationCurveUserInfoKey] as? NSNumber
        let animationCurveRaw = animationCurveRawNSN?.uintValue ?? UIView.AnimationOptions.curveEaseInOut.rawValue
        let animationCurve = UIView.AnimationOptions(rawValue: animationCurveRaw)

        // Animate the view you care about
        UIView.animate(withDuration: duration, delay: 0, options: animationCurve, animations: {
            self.bottomConstraint.constant = bottomConstraintConstant
            self.view.layoutIfNeeded()
        }, completion: nil)
    }
}

2

मैंने निम्नलिखित तरीके से किया है:

यह तब उपयोगी होता है जब टेक्स्टफील्ड सुपरविवे व्यू होता है

class AdminLoginViewController: UIViewController,
UITextFieldDelegate{

    @IBOutlet weak var txtUserName: UITextField!
    @IBOutlet weak var txtUserPassword: UITextField!
    @IBOutlet weak var btnAdminLogin: UIButton!

    private var activeField : UIView?

    var param:String!
    var adminUser : Admin? = nil
    var kbHeight: CGFloat!

    override func viewDidLoad()
    {
        self.addKeyBoardObserver()
        self.addGestureForHideKeyBoard()
    }

    override func viewWillDisappear(animated: Bool) {
        super.viewWillDisappear(animated)
    }
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }

    func addGestureForHideKeyBoard()
    {
        let tapGesture = UITapGestureRecognizer(target: self, action: Selector("hideKeyboard"))
        tapGesture.cancelsTouchesInView = false
        view.addGestureRecognizer(tapGesture)
    }

    func hideKeyboard() {
        self.view.endEditing(true)
    }

    func addKeyBoardObserver(){

        NSNotificationCenter.defaultCenter().addObserver(self, selector: "willChangeKeyboardFrame:",
name:UIKeyboardWillShowNotification, object: nil)
        NSNotificationCenter.defaultCenter().addObserver(self, selector: "willChangeKeyboardFrame:",
name:UIKeyboardWillHideNotification, object: nil)
    }

    func removeObserver(){
        NSNotificationCenter.defaultCenter().removeObserver(self)
    }

    //MARK:- textfiled Delegate

    func textFieldShouldBeginEditing(textField: UITextField) -> Bool
    {
         activeField = textField

        return true
    }
    func textFieldShouldEndEditing(textField: UITextField) -> Bool
    {
        if activeField == textField
        {
            activeField = nil
        }

        return true
    }

    func textFieldShouldReturn(textField: UITextField) -> Bool {

        if txtUserName == textField
        {
            txtUserPassword.becomeFirstResponder()
        }
        else if (textField == txtUserPassword)
        {
            self.btnAdminLoginAction(nil)
        }
        return true;
    }

    func willChangeKeyboardFrame(aNotification : NSNotification)
    {
       if self.activeField != nil && self.activeField!.isFirstResponder()
    {
        if let keyboardSize =  (aNotification.userInfo![UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue()
        {
            let dy = (self.activeField?.superview?.convertRect((self.activeField?.frame)!, toView: view).origin.y)!

            let height = (self.view.frame.size.height - keyboardSize.size.height)

            if dy > height
            {
                var frame = self.view.frame

                frame.origin.y = -((dy - height) + (self.activeField?.frame.size.height)! + 20)

                self.view.frame = frame
            }
        }
    }
    else
    {
        var frame = self.view.frame
        frame.origin.y = 0
        self.view.frame = frame
    }
    } }

2
    func registerForKeyboardNotifications(){
        //Keyboard
        NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(keyboardWasShown), name: UIKeyboardDidShowNotification, object: nil)
        NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(keyboardWillBeHidden), name: UIKeyboardDidHideNotification, object: nil)


    }
    func deregisterFromKeyboardNotifications(){

        NSNotificationCenter.defaultCenter().removeObserver(self, name: UIKeyboardWillShowNotification, object: nil)
        NSNotificationCenter.defaultCenter().removeObserver(self, name: UIKeyboardWillHideNotification, object: nil)

    }
    func keyboardWasShown(notification: NSNotification){

        let userInfo: NSDictionary = notification.userInfo!
        let keyboardInfoFrame = userInfo.objectForKey(UIKeyboardFrameEndUserInfoKey)?.CGRectValue()

        let windowFrame:CGRect = (UIApplication.sharedApplication().keyWindow!.convertRect(self.view.frame, fromView:self.view))

        let keyboardFrame = CGRectIntersection(windowFrame, keyboardInfoFrame!)

        let coveredFrame = UIApplication.sharedApplication().keyWindow!.convertRect(keyboardFrame, toView:self.view)

        let contentInsets = UIEdgeInsetsMake(0, 0, (coveredFrame.size.height), 0.0)
        self.scrollViewInAddCase .contentInset = contentInsets;
        self.scrollViewInAddCase.scrollIndicatorInsets = contentInsets;
        self.scrollViewInAddCase.contentSize = CGSizeMake((self.scrollViewInAddCase.contentSize.width), (self.scrollViewInAddCase.contentSize.height))

    }
    /**
     this method will fire when keyboard was hidden

     - parameter notification: contains keyboard details
     */
    func keyboardWillBeHidden (notification: NSNotification) {

        self.scrollViewInAddCase.contentInset = UIEdgeInsetsZero
        self.scrollViewInAddCase.scrollIndicatorInsets = UIEdgeInsetsZero

    }

1
टेक्स्ट फ़ील्ड को स्विफ्ट 2.2 से ऊपर ले जाने के लिए उपरोक्त कोड का उपयोग करें। यह ठीक काम करेगा। मुझे आशा है कि यह कुछ मदद करेगा।
कमलकुमार.ई

1

मैंने निम्नलिखित तरीके से किया है:

class SignInController: UIViewController , UITextFieldDelegate {

@IBOutlet weak var scrollView: UIScrollView!

// outlet declartion
@IBOutlet weak var signInTextView: UITextField!

var kbHeight: CGFloat!

/**
*
* @method viewDidLoad
*
*/

override func viewDidLoad() {
    super.viewDidLoad()

    self.signInTextView.delegate = self

}// end viewDidLoad

/**
*
* @method viewWillAppear
*
*/

override func viewWillAppear(animated: Bool) {
    super.viewWillAppear(animated)

    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillShow:"), name: UIKeyboardWillShowNotification, object: nil)

    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillHide:"), name: UIKeyboardWillHideNotification, object: nil)

}// end viewWillAppear

/**
*
* @method viewDidAppear
*
*/

override func viewDidAppear(animated: Bool) {
    super.viewDidAppear(animated)


}// end viewDidAppear

/**
*
* @method viewWillDisappear
*
*/
override func viewWillDisappear(animated: Bool) {
    super.viewWillDisappear(animated)
    NSNotificationCenter.defaultCenter().removeObserver(self)
}

/**
*
* @method textFieldShouldReturn
* retun the keyboard value
*
*/

// MARK -
func textFieldShouldReturn(textField: UITextField) -> Bool {
    signInTextView.resignFirstResponder()
    return true;

}// end textFieldShouldReturn

// MARK - keyboardWillShow
func keyboardWillShow(notification: NSNotification) {
    if let userInfo = notification.userInfo {
        if let keyboardSize =  (userInfo[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
            kbHeight = keyboardSize.height
            self.animateTextField(true)
        }
    }
}// end keyboardWillShow

// MARK - keyboardWillHide
func keyboardWillHide(notification: NSNotification) {
    self.animateTextField(false)
}// end keyboardWillHide

// MARK - animateTextField
func animateTextField(up: Bool) {
    var movement = (up ? -kbHeight : kbHeight)

    UIView.animateWithDuration(0.3, animations: {
        self.view.frame = CGRectOffset(self.view.frame, 0, movement)
    })
}// end animateTextField

/**
*
* @method didReceiveMemoryWarning
*
*/

override func didReceiveMemoryWarning() {
    super.didReceiveMemoryWarning()
    // Dispose of any resources that can be recreated.

}// end didReceiveMemoryWarning


}// end SignInController

1

यदि आप मेरे जैसे हैं, जिन्होंने उपरोक्त सभी समाधानों की कोशिश की है और अभी भी आपकी समस्या हल नहीं हुई है, तो मेरे पास आपके लिए एक शानदार समाधान है जो एक आकर्षण की तरह काम करता है। पहले मैं ऊपर वर्णित कुछ समाधानों के बारे में कुछ बातें स्पष्ट करना चाहता हूं।

  1. मेरे मामले में IQkeyboardmanager केवल तभी काम कर रहा था जब तत्वों पर कोई ऑटो लेआउट लागू नहीं है, अगर इसे लागू किया जाता है तो IQkeyboard प्रबंधक हमारे सोचने के तरीके पर काम नहीं करेगा।
  2. ऊपर की गति के साथ एक ही बात स्व.विकास के ।
  3. मेरे पास यूआईटेक्सफील्ड को ऊपर की ओर धकेलने के लिए एक तेज़ सी हेडर के साथ एक ऑब्जेक्टिव c हेडर है, जब यूजर उस पर क्लिक करता है, जिससे UITextfield को कवर करने वाले कीबोर्ड की समस्या हल होती है: https://github.com/coolvasanth/smart_keyboard
  4. IOS ऐप डेवलपमेंट में इंटरमीडिएट या उच्च स्तर वाले व्यक्ति आसानी से रिपॉजिटरी को समझ सकते हैं और इसे लागू कर सकते हैं। शुभकामनाएं

1

यहाँ सभी TextField चरणों के लिए एक सामान्य समाधान है -

1) एक सामान्य ViewController बनाएं जो अन्य ViewControllers द्वारा विस्तारित है

override func viewDidLoad() {
    super.viewDidLoad()
    NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow), name: UIResponder.keyboardWillShowNotification, object: nil)
    NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide), name: UIResponder.keyboardWillHideNotification, object: nil)

}
 @objc func keyboardWillShow(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIResponder.keyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        if self.view.frame.origin.y == 0 {
            self.view.frame.origin.y -= getMoveableDistance(keyboarHeight: keyboardSize.height)
        }
    }
}

@objc func keyboardWillHide(notification: NSNotification) {
    if self.view.frame.origin.y != 0 {
        self.view.frame.origin.y = 0
    }
}
deinit {
    NotificationCenter.default.removeObserver(self)
}

//get the distance to move up the main view for the focus textfiled
func getMoveableDistance(keyboarHeight : CGFloat) ->  CGFloat{
    var y:CGFloat = 0.0
    if let activeTF = getSelectedTextField(){
        var tfMaxY = activeTF.frame.maxY
        var containerView = activeTF.superview!
        while containerView.frame.maxY != self.view.frame.maxY{
            let contViewFrm = containerView.convert(activeTF.frame, to: containerView.superview)
            tfMaxY = tfMaxY + contViewFrm.minY
            containerView = containerView.superview!
        }
        let keyboardMinY = self.view.frame.height - keyboarHeight
        if tfMaxY > keyboardMinY{
            y = (tfMaxY - keyboardMinY) + 10.0
        }
    }

    return y
}

2) UIViewController और वर्तमान में सक्रिय TextField का विस्तार बनाएँ

//get active text field

एक्सटेंशन UIViewController {func getSelectedTextField () -> UITextField? {

    let totalTextFields = getTextFieldsInView(view: self.view)

    for textField in totalTextFields{
        if textField.isFirstResponder{
            return textField
        }
    }

    return nil

}

func getTextFieldsInView(view: UIView) -> [UITextField] {

    var totalTextFields = [UITextField]()

    for subview in view.subviews as [UIView] {
        if let textField = subview as? UITextField {
            totalTextFields += [textField]
        } else {
            totalTextFields += getTextFieldsInView(view: subview)
        }
    }

    return totalTextFields
}

}


किसी कारण से, मैं कीबोर्डव्हीलशो फ़ंक्शन में एक समस्या हो रही थी, पहले कीबोर्ड टॉगल (पहले टॉगल में सही फ्रेम है) के बाद कीबोर्डसाइज़ को गलत आकार मिल रहा था। मैंने इसे बदल कर तय किया है कि यूजर को जाने दो। Info = notification.userInfo और {return} गार्ड को कीबोर्ड बताएं = userInfo [UIResponder.keyboardFrameEndUserInfoKey] के रूप में? NSValue वरना {वापसी} कीबोर्डफ्रेम = कीबोर्ड को आकार दें। अगर किसी को एक ही मुद्दा मिला :)
यूस्टोनजर 5

1

बहुत सरल और अधिक कोड की आवश्यकता नहीं है। बस pod 'IQKeyboardManagerSwift'अपने पॉडफाइल में जोड़ें , और अपने AppDelegateपेज में नीचे कोड जोड़ें।

import IQKeyboardManagerSwift

और विधि didFinishLaunchingWithOptions()प्रकार में

IQKeyboardManager.shared.enable = true

बस इतना ही। बेहतर समझ के लिए इस वीडियो लिंक की जाँच करें https://youtu.be/eOM94K1ZWN8 आशा है कि यह आपकी मदद करेगा।


क्या यह टेक्स्ट व्यू के लिए काम करता है और मैं रिटर्न कुंजी "डन" के लिए शीर्षक कैसे बदल सकता हूं?
tdt kien

: स्व क्रिया: @ डिलेक्टर (किया गया कार्य :) shouldShowPlaceholder: _shouldShowTextFieldPlaceholder]; और टेक्स्टव्यू के लिए अभी तक कोशिश नहीं की है, आशा है कि यह आपकी मदद करेगा।
रघिब अर्शी

1

कीबोर्ड प्रबंधन के लिए पूरा कोड।

        override func viewWillAppear(_ animated: Bool) {
            NotificationCenter.default.addObserver(self, selector: #selector(StoryMediaVC.keyboardWillShow), name: UIResponder.keyboardWillShowNotification, object: nil)
            NotificationCenter.default.addObserver(self, selector: #selector(StoryMediaVC.keyboardWillHide), name: UIResponder.keyboardWillHideNotification, object: nil)
        }
        override func viewWillDisappear(_ animated: Bool) {
            NotificationCenter.default.removeObserver(self, name: UIResponder.keyboardWillShowNotification, object: nil)
            NotificationCenter.default.removeObserver(self, name: UIResponder.keyboardWillHideNotification, object: nil)
        }
        @objc func keyboardWillShow(notification: NSNotification) {
            guard let userInfo = notification.userInfo else {return}
            guard let keyboardSize = userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue else {return}
            let keyboardFrame = keyboardSize.cgRectValue

            if self.view.bounds.origin.y == 0{
                self.view.bounds.origin.y += keyboardFrame.height
            }
        }


        @objc func keyboardWillHide(notification: NSNotification) {
            if self.view.bounds.origin.y != 0 {
                self.view.bounds.origin.y = 0
            }
        }

0

मैंने @Simpa समाधान को थोड़ा संशोधित किया ........।

override func viewDidLoad() 
{

    super.viewDidLoad()
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("makeSpaceForKeyboard:"), name:UIKeyboardWillShowNotification, object: nil);
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("makeSpaceForKeyboard:"), name:UIKeyboardWillHideNotification, object: nil);
}

deinit{
    NSNotificationCenter.defaultCenter().removeObserver(self)
}

var keyboardIsVisible = false
override func makeSpaceForKeyboard(notification: NSNotification) {

    let info = notification.userInfo!
    let keyboardHeight:CGFloat = (info[UIKeyboardFrameEndUserInfoKey] as! NSValue).CGRectValue().size.height
    let duration:Double = info[UIKeyboardAnimationDurationUserInfoKey] as! Double

    if notification.name == UIKeyboardWillShowNotification && keyboardIsVisible == false{

        keyboardIsVisible = true

        UIView.animateWithDuration(duration, animations: { () -> Void in
            var frame = self.view.frame
            frame.size.height = frame.size.height - keyboardHeight
            self.view.frame = frame
        })

    } else if keyboardIsVisible == true && notification.name == UIKeyboardWillShowNotification{

    }else {
        keyboardIsVisible = false

        UIView.animateWithDuration(duration, animations: { () -> Void in
            var frame = self.view.frame
            frame.size.height = frame.size.height + keyboardHeight
            self.view.frame = frame
        })
    }
}

0

उनमें से किसी ने भी काम नहीं किया और कीबोर्ड दिखाई देने पर मैंने अपने दृश्य को स्थानांतरित करने के लिए सामग्री इनसेट का उपयोग किया।

ध्यान दें: मैं UITableView का उपयोग कर रहा था

संदर्भित समाधान @ कीबोर्ड-सामग्री-ऑफ़सेट जो पूरी तरह से उद्देश्य सी में लिखा गया था, नीचे का समाधान स्वच्छ स्विफ्ट है।

अधिसूचना पर्यवेक्षक @ viewDidLoad () जोड़ें

NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(yourClass.keyboardWillBeShown), name:UIKeyboardWillShowNotification, object: nil);
NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(yourClass.keyboardWillBeHidden), name:UIKeyboardWillHideNotification, object: nil);

कीबोर्ड का आकार प्राप्त करने के लिए, हमें सबसे पहले userInfo डिक्शनरी को नोटिफिकेशन ऑब्जेक्ट से प्राप्त करना होता है, जो कि हमारे रिसीवर का उपयोग करने वाली किसी भी अतिरिक्त वस्तुओं को संग्रहीत करता है।

उस शब्दकोश से हम कुंजी UIKeyboardFrameBeginUserInfoKey का उपयोग करके कीबोर्ड के फ्रेम का वर्णन करते हुए CGRect ऑब्जेक्ट प्राप्त कर सकते हैं।

तालिका दृश्य @ keyboardWillBeShown विधि के लिए सामग्री इनसेट लागू करें,

func keyboardWillBeShown(sender: NSNotification)
{        
    // Move the table view

    if let keyboardSize = (sender.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue()
    {
        let contentInsets = UIEdgeInsetsMake(0.0, 0.0, (keyboardSize.height), 0.0);

        yourTableView.contentInset = contentInsets;

        yourTableView.scrollIndicatorInsets = contentInsets;
    }
}

@ कीबोर्ड वॉलेट विधि को पुनर्स्थापित करें

func keyboardWillBeHidden(sender: NSNotification)
{
    // Moving back the table view back to the default position

    yourTableView.contentInset = UIEdgeInsetsZero;

    yourTableView.scrollIndicatorInsets = UIEdgeInsetsZero;
}

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

// Portrait
UIEdgeInsetsMake(0.0, 0.0, (keyboardSize.height), 0.0);

// Landscape
UIEdgeInsetsMake(0.0, 0.0, (keyboardSize.width), 0.0);

0
override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view, typically from a nib.

    NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
    NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
}

func keyboardWillShow(_ notification:Notification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        tableView.contentInset = UIEdgeInsetsMake(0, 0, keyboardSize.height, 0)
    }
}

func keyboardWillHide(_ notification:Notification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        tableView.contentInset = UIEdgeInsetsMake(0, 0, 0, 0)
    }
}

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


0

स्विफ्ट 4 समाधान मैं उपयोग करता हूं, कीबोर्ड आकार में लेता है। serverStatusStackViewआप जिस भी चीज़ की परवाह करते हैं, उसे बदलें जैसे self.view:

deinit {
    NotificationCenter.default.removeObserver(self)
}

@objc func keyboardWillShow(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        serverStatusStackView.frame.origin.y = keyboardSize.height * 2 - serverStatusStackView.frame.height
    }
}

@objc func keyboardWillHide(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        serverStatusStackView.frame.origin.y += keyboardSize.height
    }
}

override func viewDidLoad() {
    super.viewDidLoad()
    NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow(notification:)), name: NSNotification.Name.UIKeyboardWillShow, object: nil)

    NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide(notification:)), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
}

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