स्विफ्ट का उपयोग करके कीबोर्ड के साथ देखें

Question

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

टाइप करने के दौरान मैं ऊपर की ओर देखने के बारे में कैसे जाऊंगा, इसलिए मैं देख सकता हूं कि मैं क्या टाइप कर रहा हूं और फिर कीबोर्ड के गायब होने पर इसे वापस अपने मूल स्थान पर ले जा रहा हूं?

मैंने हर जगह देखा है, लेकिन सभी समाधान ओबज-सी में दिखाई देते हैं जो मैं अभी तक परिवर्तित नहीं कर सकता हूं।

किसी भी तरह की सहायता का स्वागत किया जाएगा।

Comments

यह करने के लिए सबसे अच्छा तरीका है एक के अंदर अपनी सामग्री जगह है UIScrollView , तो पुस्तक को देखने के समायोजित contentInset जब यह दिखाया गया है कीबोर्ड की ऊंचाई से संपत्ति। बिल्कुल कीबोर्ड की ऊँचाई को नहीं मानते हैं - "कीबोर्ड दिखाएगा" अधिसूचना से मूल्य का उपयोग करें।

— नील्सबोट

वास्तव में, Apple डॉक्स आपको बताता है कि "कीबोर्ड का प्रबंधन" के तहत यह कैसे किया जाए: developer.apple.com/library/ios/documentation/StringsTextFonts/…

— nielsbot

मुझे लगता है कि नीचे दिए गए सभी उत्तर एक मामले को ध्यान में नहीं रखते हैं: क्या होगा यदि आपके पास कई टेक्स्टफील्ड हैं और उनमें से कुछ स्क्रीन के शीर्ष पर स्थित हैं? जब भी कोई उपयोगकर्ता उस टेक्स्टफ़ील्ड पर टैप करता है, तो वह स्क्रीन से परे चला जाता है, मुझे पूरा यकीन है कि सही उत्तर का पता लगाना चाहिए कि क्या हैit is actually needed to scroll view up when keyboard appears

— डीडीसी

यह उत्तर यह पता लगाने में सक्षम है कि क्या कीबोर्ड को चेक करके दिखाई देने पर वास्तव में इसकी आवश्यकता है कि क्या

— टेक्स्टफील्ड

Answer 1

यहां एक समाधान है, एक टेक्स्टफिल्ड से दूसरे में स्विच को संभालने के बिना:

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

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

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

इसे हल करने के लिए, keyboardWillShow/Hideइन दोनों कार्यों को प्रतिस्थापित करें :

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

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

स्विफ्ट 3.0 के लिए संपादित करें:

override func viewDidLoad() {
    super.viewDidLoad()            
    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)    
}

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

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

स्विफ्ट 4.0 के लिए संपादित करें:

override func viewDidLoad() {
    super.viewDidLoad()            
    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)    
}

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

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

स्विफ्ट 4.2 के लिए संपादित करें:

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.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
        if self.view.frame.origin.y == 0 {
            self.view.frame.origin.y -= keyboardSize.height
        }
    }
}

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

Comments

यदि उपयोगकर्ता किसी अन्य टेक्स्ट फ़ील्ड को स्पर्श करता है, जबकि कीबोर्ड मौजूद है, तो दृश्य को और ऊपर धकेल दिया जाएगा, जो एक ब्लैक एरिया (कीबोर्ड का आकार) का कारण बनता है - हमें यह तय करने की आवश्यकता है कि एक चर होने से यह पता चलता है कि कीबोर्ड मौजूद है या नहीं । उदाहरण के लिए अगर

— कीबोर्डप्रेसेन्ट

@ मैट्टू लिन एक बूलियन का उपयोग करते हैं ताकि फंक्शंस कीबोर्डव्हीलशो और केवल एक बार

— छुपकर

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

— वंदन पटेल

कीबोर्ड का आकार प्राप्त करने के UIKeyboardFrameEndUserInfoKeyबजाय आपको इसका उपयोग UIKeyboardFrameBeginUserInfoKeyकरने की आवश्यकता है। मुझे यकीन नहीं है कि इस समय क्यों, लेकिन पूर्व अधिक सुसंगत परिणाम देगा।

— जशपी 8

कृपया के UIKeyboardFrameBeginUserInfoKeyसाथ बदलें UIKeyboardFrameEndUserInfoKey। पहला व्यक्ति कीबोर्ड का स्टार्ट फ्रेम देता है, जो कभी-कभी शून्य आता है, जबकि दूसरा कीबोर्ड का अंतिम फ्रेम देता है।

— अर्नब

Answer 2

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

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

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

Comments

नीचे की बाधा का चयन करने के लिए आप साइज इंस्पेक्टर के पास भी जा सकते हैं, फिर सूची में बाधा पर डबल क्लिक करें - raywenderlich.com/wp-content/uploads/2015/09/…

— gammachill

इसने मेरे लिए एकदम सही काम किया। यह सचमुच एक 2 कदम प्रक्रिया है। 1. KeyboardLayoutConstraint.swift जोड़ें, 2. स्टोरीबोर्ड में, दृश्य या पाठ फ़ील्ड के लिए एक निचला अवरोध बनाएं। नोट: मैंने अपनी बाधाओं को हटा दिया और दृश्य या टेक्स्टफ़ील्ड के नीचे सिर्फ 1 बाधा जोड़ी और NSLayoutConstraint से KeyboardLayoutConstraint तक अपनी कक्षा बदल दी। फिर ऊपर किसी भी विचार / textfields इत्यादि मैं उस आइटम से एक ही कीबोर्ड के साथ कनेक्ट किए गए बाधाओं को कनेक्ट किया गया है एक परिणाम के रूप में कीबोर्डऑन्टरट्रिंट और परिणाम सभी आइटम यूपी में चले गए / जब बोर्ड कुंजी / गायब हो गए तो दिखाई दिया

— ब्रायन

यह सबसे अच्छा समाधान है, बशर्ते कोड किसी भी मूल्य जैसे एनीमेशन की लंबाई या वक्र, या कीबोर्ड के आकार को हार्डकोड नहीं करता है। इसे समझना भी आसान है।

— मिगुएल सैंसिरिसो

यह मेरे लिए काम कर रहा है, लेकिन मुझे कीबोर्ड के शीर्ष और मेरे स्क्रॉल दृश्य के निचले भाग के बीच अतिरिक्त 50px का स्थान मिलता है। मैं सोच रहा था कि यह सुरक्षित क्षेत्र नीचे बाधा के कारण मैं उपयोग कर रहा हूँ। इसमें कोई चला?

— क्लिफ्टन लैब्रम

यह एक कमाल का जवाब था। बहुत ही शांत डिजाइन। एक सुझाव: यदि आपके टेक्स्टव्यू / टेक्स्ट फील्ड्स टेबल व्यू सेल पर हैं, तो आप उन विचारों को नोटिस कर सकते हैं जिनमें यह बाधा है कि उपयोगकर्ता क्लिक करने और अगले टेक्स्ट फ़ील्ड में जाने पर हर बार अजीब तरह से कूद जाएगा। आप DispatchQueue.main.async {}इसे ठीक करने के लिए एनिमेशन को लपेट सकते हैं । अच्छा कार्य! थम्स अप!

— स्कॉट्टीब्लाड्स

Answer 3

इस थ्रेड पर लोकप्रिय उत्तरों में से एक निम्नलिखित कोड का उपयोग करता है:

func keyboardWillShow(sender: NSNotification) {
    self.view.frame.origin.y -= 150
}
func keyboardWillHide(sender: NSNotification) {
    self.view.frame.origin.y += 150
}

एक स्थिर राशि द्वारा आपके विचार को ऑफसेट करने के साथ एक स्पष्ट समस्या है। यह एक डिवाइस पर अच्छा लगेगा, लेकिन किसी अन्य आकार के कॉन्फ़िगरेशन पर बुरा लगेगा। आपको कीबोर्ड की ऊंचाई प्राप्त करने और अपने ऑफसेट मूल्य के रूप में उपयोग करने की आवश्यकता होगी।

यहां एक समाधान है जो सभी उपकरणों पर काम करता है और धार-मामले को संभालता है जहां उपयोगकर्ता टाइप करते समय भविष्य कहनेवाला पाठ क्षेत्र छुपाता है।

उपाय

नीचे नोट करने के लिए महत्वपूर्ण है, हम अपने ऑब्जेक्ट पैरामीटर के रूप में self.view.window पास कर रहे हैं। यह हमें हमारे कीबोर्ड से डेटा प्रदान करेगा, जैसे कि इसकी ऊंचाई!

@IBOutlet weak var messageField: UITextField!

override func viewDidLoad() {
    super.viewDidLoad()

    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillShow:"), name:UIKeyboardWillShowNotification, object: self.view.window)
    NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillHide:"), name:UIKeyboardWillHideNotification, object: self.view.window)
}

func keyboardWillHide(sender: NSNotification) {
    let userInfo: [NSObject : AnyObject] = sender.userInfo!
    let keyboardSize: CGSize = userInfo[UIKeyboardFrameBeginUserInfoKey]!.CGRectValue.size
    self.view.frame.origin.y += keyboardSize.height
}

हम इसे सभी उपकरणों पर अच्छा दिखेंगे और उस केस को संभालेंगे जहाँ उपयोगकर्ता पूर्वानुमान पाठ क्षेत्र को जोड़ता या हटाता है।

func keyboardWillShow(sender: NSNotification) {
    let userInfo: [NSObject : AnyObject] = sender.userInfo!
    let keyboardSize: CGSize = userInfo[UIKeyboardFrameBeginUserInfoKey]!.CGRectValue.size
    let offset: CGSize = userInfo[UIKeyboardFrameEndUserInfoKey]!.CGRectValue.size

    if keyboardSize.height == offset.height {
        UIView.animateWithDuration(0.1, animations: { () -> Void in
            self.view.frame.origin.y -= keyboardSize.height
        })
    } else {
        UIView.animateWithDuration(0.1, animations: { () -> Void in
            self.view.frame.origin.y += keyboardSize.height - offset.height
        })
    }
}

प्रेक्षकों को हटा दें

अनावश्यक संदेशों को प्रेषित होने से रोकने के लिए देखने से पहले अपने पर्यवेक्षकों को हटाना न भूलें।

override func viewWillDisappear(animated: Bool) {
    NSNotificationCenter.defaultCenter().removeObserver(self, name: UIKeyboardWillShowNotification, object: self.view.window)
    NSNotificationCenter.defaultCenter().removeObserver(self, name: UIKeyboardWillHideNotification, object: self.view.window)
}

---

टिप्पणियों से प्रश्न के आधार पर अपडेट करें:

यदि आपके पास दो या अधिक पाठ-क्षेत्र हैं, तो आप यह देख सकते हैं कि आपका view.frame.origin.y शून्य पर है या नहीं।

func keyboardWillShow(sender: NSNotification) {
    let userInfo: [NSObject : AnyObject] = sender.userInfo!

    let keyboardSize: CGSize = userInfo[UIKeyboardFrameBeginUserInfoKey]!.CGRectValue.size
    let offset: CGSize = userInfo[UIKeyboardFrameEndUserInfoKey]!.CGRectValue.size

    if keyboardSize.height == offset.height {
        if self.view.frame.origin.y == 0 {
            UIView.animateWithDuration(0.1, animations: { () -> Void in
                self.view.frame.origin.y -= keyboardSize.height
            })
        }
    } else {
        UIView.animateWithDuration(0.1, animations: { () -> Void in
            self.view.frame.origin.y += keyboardSize.height - offset.height
        })
    }
     print(self.view.frame.origin.y)
}

Comments

जब कई पाठ क्षेत्रों के साथ काम करते हैं, तो दृश्य आगे बढ़ता रहता है और वापस नहीं आता है

— मुगुतथन बालकृष्णन

आप पाठ फ़ील्ड के लिए अपनी शर्तों को बदलने के लिए जा रहे हैं

— Dan Beaulieu

प्रतिक्रिया के लिए धन्यवाद, मुझे जवाब मिला कि मैं स्टैक ओवरफ्लो पर इस धागे की तलाश कर रहा था stackoverflow.com/questions/1126726/…

— मुगुनथन बालकृष्णन

@ मुगुनथानबालकृष्णन को इसे लाने के लिए धन्यवाद, मैंने एक समाधान जोड़ा है।

— डैन ब्यूलियू

हाय दोस्तों, एक बग है। व्यूअरडिसपियर में देखे जाने के बाद पर्यवेक्षकों को दृश्य से हटाया नहीं जाता है। इस पंक्ति को "NSNotificationCenter.defaultCenter ()। RemoveObserver (self, name: UIKeyboardWillHideNotification, ऑब्जेक्ट: self.view.window)" के साथ "NSNotificationCenter.defaultCenter" () .OOserver (स्वयं, नाम: UIKeyboardWillHillHillHillHillHideNotification से हटाएं)। निकाल दिया जाता है

— रुडल

Answer 4

इसे अपने viewcontroller में जोड़ें। एक जादू की तरह काम करता है। बस मूल्यों को समायोजित करें।

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

@objc func keyboardWillShow(sender: NSNotification) {
    self.view.frame.origin.y -= 150
}
@objc func keyboardWillHide(sender: NSNotification) {
    self.view.frame.origin.y += 150
}

Comments

यह मेरे लिए काम करता है। हालाँकि यह थोड़ा झटकेदार है। स्मूथली को स्थानांतरित करने के लिए मुझे यह कैसे मिल सकता है? यह भी एक तरीका है कि इसे केवल एक टेक्स्टफिल्ड पर लागू किया जाए क्योंकि यह वर्तमान में सभी के लिए ऐसा करता है। :(

— DannieCoderBoi

यह "ऑटो-लेआउट" के साथ काम नहीं कर सकता है इसलिए यदि ऐसा है तो इसे निष्क्रिय करने पर विचार करें।

— तियोदोर सियारारू

यह autolayout @Josh के साथ कुछ मज़ेदार व्यवहार का कारण बनता है, आप गलत हैं

— माइक

यह मत करो! आप यह नहीं मान सकते कि कीबोर्ड एक निश्चित आकार है।

— नील्सबॉट

कीबोर्ड का उपयोग करना चाहिए। क्या होता है जब आपके पास एक्सेसरी व्यूज़ और डिवाइसेस पर अलग-अलग कीबोर्ड हाइट होते हैं? अलग कीबोर्ड?

— २२:५२ पर xtrinch

Answer 5

मैंने एक पृष्ठ पर विभिन्न कीबोर्ड और अलग-अलग पाठ्यपुस्तकों / क्षेत्रों के साथ काम करने के लिए उत्तरों में से एक को थोड़ा सुधार दिया:

पर्यवेक्षक जोड़ें:

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

    NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillChange(notification:)), name: UIResponder.keyboardWillChangeFrameNotification, object: nil)

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

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

func keyboardWillChange(notification: NSNotification) {

    if let keyboardSize = (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
        if YOURTEXTVIEW.isFirstResponder {
            self.view.frame.origin.y = -keyboardSize.height
        }
    }
}

पर्यवेक्षक निकालें:

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

    NotificationCenter.default.removeObserver(self, name: UIResponder.keyboardWillChangeFrameNotification, object: nil)
    NotificationCenter.default.removeObserver(self, name: UIResponder.keyboardWillHideNotification, object: nil)
}

Comments

यह समाधान स्वीकृत उत्तर की तुलना में बेहतर काम करता है। स्वीकृत उत्तर कीबोर्ड को केवल एक बार दिखाता है जो मेरे लिए एक बग है :)

— Masih

यह Xcode 10.1 और iOS 12 के लिए काम करता है। स्वीकृत जवाब अब मान्य नहीं है।

— जीशान

यह एक उत्कृष्ट उत्तर है, केवल एक चीज जो मैं जोड़ूंगा वह है नए उपकरणों (एक्स, एक्सएस, आदि) में नीचे के सुरक्षित क्षेत्र का ट्रैक रखना ताकि यह उसके लिए जिम्मेदार हो।

— मुनिब

@Munib देखें stackoverflow.com/a/54993623/1485230 अन्य मुद्दों में विज़ुअलाइज़ेशन शामिल नहीं है, और कीबोर्ड ऊँचाई परिवर्तन का पालन नहीं किया जा रहा है।

— अंटीज

क्या होगा अगर मेरा टेक्स्टफिल्ड दृश्य के ऊपर है ..? मेरा मतलब है अगर मूल Y = 0 के साथ टेक्स्टफील्ड है .. ?? तब

— टेक्स्टफिल्ड

Answer 6

विज्ञापन या प्रचार या स्पैम नहीं , बस एक अच्छा समाधान है। मुझे पता है कि इस सवाल के लगभग 30 जवाब हैं और मैं इतना हैरान हूं कि किसी ने भी इस खूबसूरत GitHub परियोजना के बारे में एक बार भी उल्लेख नहीं किया है जो यह सब आपके लिए करता है और इससे भी बेहतर। सभी उत्तर बस दृश्य को ऊपर की ओर ले जाते हैं। मैंने इस IQKeyboardManager के साथ अपनी सभी समस्याओं को हल किया। इसमें 13000+ तारे हैं।
यदि आप स्विफ्ट का उपयोग कर रहे हैं तो बस इसे अपने पॉडफाइल में जोड़ें

pod 'IQKeyboardManagerSwift'

और फिर अपने AppDelegate.swift के अंदर करें import IQKeyboardManagerSwift

import IQKeyboardManagerSwift

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?

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

      IQKeyboardManager.shared.enable = true // just add this line

      return true
    }
}

IQKeyboardManager.shared.enable = trueइसे सक्षम करने के लिए लाइन जोड़ें
यह समाधान आवश्यक है यदि आप उत्पादन के लिए जा रहे हैं।

Comments

यह वास्तव में अच्छा है, लेकिन नवीनतम संस्करण मेरे लिए काम नहीं करता है, मैंने 6.2.1 का उपयोग किया है, और AppDelegate में import IQKeyboardManagerउपयोग और उपयोग किया जाता IQKeyboardManager.shared().isEnabled = trueहै

— धनु के

और यह कई संपादन ग्रंथों का उपयोग करते समय अजीब तरह से काम करता है, इससे मेरा समय बचा

— धनु के

इस अद्भुत पुस्तकालय को इंगित करने के लिए पर्याप्त धन्यवाद नहीं कर सकते। यह लाइब्रेरी अंततः सभी कीबोर्ड संबंधित बकवास के लिए अंतिम जवाब है, जिसे Apple ने कभी हल नहीं किया है। अब मैं इसे अपने सभी प्रोजेक्ट्स, नए और पुराने के लिए उपयोग कर रहा हूं, और समय और सिरदर्द को बचाएंगे जो यह कीबोर्ड दिखाई दे रहा है, गायब हो रहा है या गायब नहीं है, या इसे कैसे छिपाया जा सकता है, और यह अतिव्यापी क्यों है, मुझे तब से समस्याएं पैदा हो रही हैं दिन मैं iPhones के लिए प्रोग्रामिंग कर रहा हूँ।

— जीशान ४'१

मैंने टेक्स्टफील्ड को स्थानांतरित करने के लिए अपना खुद का कोड लिखा था, यहां के अन्य समाधानों की तरह। मैंने पाया कि IQKeyboardManager बहुत अच्छा है और मैं इसे अभी से इसमें शामिल कर लूँगा। केवल फ्रेमवर्क को अद्यतित नहीं रखने की स्थिति में मेरा कोड काम में रखेगा।

— टीएम लिंच

@ धानुक, बस यह पुस्तकालय पाया और पूरी तरह से काम करता है और यह सरल है। एप्लिकेशन प्रतिनिधि कोड IQKeyboardManager.shared.enable को अद्यतन किया गया है सच =

— adougies

Answer 7

ब्लैक स्क्रीन एरर (स्विफ्ट 4 और 4.2) के लिए ।

मैंने ब्लैक स्क्रीन समस्या को ठीक किया। सत्यापित समाधान में कीबोर्ड की ऊंचाई टैप करने के बाद बदल जाती है और इससे काली स्क्रीन बन रही है।

UIKeyboardFrameEndUserInfoKey का उपयोग UIKeyboardFrameBeginUserInfoKey के बजाय करना है

var isKeyboardAppear = false

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

@objc func keyboardWillShow(notification: NSNotification) {
    if !isKeyboardAppear {
        if let keyboardSize = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
            if self.view.frame.origin.y == 0{
                self.view.frame.origin.y -= keyboardSize.height
            }
        }
        isKeyboardAppear = true
    }
}

@objc func keyboardWillHide(notification: NSNotification) {
    if isKeyboardAppear {
        if let keyboardSize = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
            if self.view.frame.origin.y != 0{
                self.view.frame.origin.y += keyboardSize.height
            }
        }
         isKeyboardAppear = false
    }
}

Comments

अगर कोई वर्जना है तो काम नहीं करेंगे। आपको टैब्बर की ऊँचाई की गणना करनी होगी, अन्यथा कीबोर्ड और दृश्य के बीच एक ब्लैक स्क्रीन गैप होगा।

— अंकुर लहिरि

यह उस काले क्षेत्र को ठीक नहीं करता है जहां कीबोर्ड iPhone X और नए पर था। और हर बार कीबोर्ड दिखाई देता है और गायब हो जाता है मुख्य दृश्य नीचे फिसलता रहता है।

— एडिसन

Answer 8

मुझे लगता है कि सभी उत्तर कीबोर्ड ऊंचाई के मान से ही दृश्य को आगे बढ़ा रहे हैं। खैर, मेरे पास एक विस्तृत जवाब है, जो उपयोगी हो सकता है यदि आप बाधाओं का उपयोग कर रहे हैं autolayout, यानी , एक पूर्वनिर्धारित मूल्य द्वारा इसके अवरोध मूल्य (उदाहरण के लिए नीचे या ऊपर की कमी) को बदलकर या आप कीबोर्ड आकार मान का उपयोग कर सकते हैं।

इस उदाहरण में, मैं टेक्स्टफील्ड से बॉटम लेआउट व्यू तक 175 के शुरुआती मूल्य के साथ नीचे की बाधा का उपयोग करता हूं।

@IBOutlet weak var bottomConstraint: NSLayoutConstraint!

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

func keyboardWillShow(notification: NSNotification) {
    //To retrieve keyboard size, uncomment following line
    //let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue()
    bottomConstraint.constant = 260
    UIView.animateWithDuration(0.3) {
        self.view.layoutIfNeeded()
    }
}

func keyboardWillHide(notification: NSNotification) {
    //To retrieve keyboard size, uncomment following line
    //let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue()
    bottomConstraint.constant = 175
    UIView.animateWithDuration(0.3) {
        self.view.layoutIfNeeded()
    }
}

Comments

हाय साहब, क्या आप मुझे बता सकते हैं कि यह तब क्यों काम नहीं करता जब एक दृश्य में रखा जाता है जिसमें टेबल व्यू भी होता है? यह उसी परिदृश्य में ठीक काम करता है जब इसमें एक संग्रह दृश्य होता है।

— एलार्कोइरिस

Answer 9

कुछ बदलाव हुए हैं कि हम KeyboardWillHideNotification को कैसे परिभाषित करते हैं।

यह समाधान स्विफ्ट 4.2 के साथ काम करता है :

NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillShow), name: UIResponder.keyboardWillShowNotification, object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillHide), name: UIResponder.keyboardWillHideNotification, object: nil)


@objc func keyboardWillShow(_ notification:Notification) {
    if let keyboardSize = (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
        self.view.frame.origin.y -= keyboardSize.height
    }
}

@objc func keyboardWillHide(_ notification:Notification) {
    if let keyboardSize = (notification.userInfo?[UIResponder.keyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        self.view.frame.origin.y += keyboardSize.height
    }
}

Comments

क्या होगा अगर मेरा टेक्स्टफिल्ड दृश्य के ऊपर है ..? मेरा मतलब है अगर मूल Y = 0 के साथ टेक्स्टफील्ड है .. ?? तब

— टेक्स्टफिल्ड

Answer 10

स्विफ्ट 5.0:

4-5 घंटे की लड़ाई के बाद मैं UIViewController के सरल कोड के साथ एक सरल एक्सटेंशन के साथ आया जो आकर्षण की तरह काम करता है

जब TextField कीबोर्ड के ऊपर है, तो दृश्य को स्थानांतरित नहीं करना चाहिए

* NSLayoutConstraint के लिए निरंतर मूल्य निर्धारित करने की आवश्यकता नहीं है

* किसी तीसरे पक्ष के पुस्तकालय की आवश्यकता नहीं

* कोई एनीमेशन कोड की आवश्यकता है

* टेबलव्यू पर भी काम करता है

* यह ऑटो लेआउट / ऑटो आकार पर काम करता है

extension UIViewController {
    func addKeyboardObserver() {
        NotificationCenter.default.addObserver(self, selector: #selector(keyboardNotifications(notification:)),
                                               name: UIResponder.keyboardWillChangeFrameNotification,
                                               object: nil)
    }

    func removeKeyboardObserver(){
        NotificationCenter.default.removeObserver(self, name: UIResponder.keyboardWillChangeFrameNotification, object: nil)
    }

    // This method will notify when keyboard appears/ dissapears
    @objc func keyboardNotifications(notification: NSNotification) {

        var txtFieldY : CGFloat = 0.0  //Using this we will calculate the selected textFields Y Position
        let spaceBetweenTxtFieldAndKeyboard : CGFloat = 5.0 //Specify the space between textfield and keyboard


        var frame = CGRect(x: 0, y: 0, width: 0, height: 0)
        if let activeTextField = UIResponder.currentFirst() as? UITextField ?? UIResponder.currentFirst() as? UITextView {
            // Here we will get accurate frame of textField which is selected if there are multiple textfields
            frame = self.view.convert(activeTextField.frame, from:activeTextField.superview)
            txtFieldY = frame.origin.y + frame.size.height
        }

        if let userInfo = notification.userInfo {
            // here we will get frame of keyBoard (i.e. x, y, width, height)
            let keyBoardFrame = (userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue
            let keyBoardFrameY = keyBoardFrame!.origin.y
            let keyBoardFrameHeight = keyBoardFrame!.size.height

            var viewOriginY: CGFloat = 0.0
            //Check keyboards Y position and according to that move view up and down
            if keyBoardFrameY >= UIScreen.main.bounds.size.height {
                viewOriginY = 0.0
            } else {
                // if textfields y is greater than keyboards y then only move View to up
                if txtFieldY >= keyBoardFrameY {

                    viewOriginY = (txtFieldY - keyBoardFrameY) + spaceBetweenTxtFieldAndKeyboard

                    //This condition is just to check viewOriginY should not be greator than keyboard height
                    // if its more than keyboard height then there will be black space on the top of keyboard.
                    if viewOriginY > keyBoardFrameHeight { viewOriginY = keyBoardFrameHeight }
                }
            }

            //set the Y position of view
            self.view.frame.origin.y = -viewOriginY
        }
    }
}

UIResponder के इस एक्सटेंशन को जोड़ने के लिए जिसे TextField चुना गया है

extension UIResponder {

    static weak var responder: UIResponder?

    static func currentFirst() -> UIResponder? {
        responder = nil
        UIApplication.shared.sendAction(#selector(trap), to: nil, from: nil, for: nil)
        return responder
    }

    @objc private func trap() {
        UIResponder.responder = self
    }
}

फिर अपने किसी भी ViewController में इस का उपयोग करें

   override func viewWillAppear(_ animated: Bool) {
        self.addKeyboardObserver()
    }

    override func viewWillDisappear(_ animated: Bool) {
        self.removeKeyboardObserver()
    }

---

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

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

  यहाँ डेमो डाउनलोड करें

Comments

यह सबसे अच्छा समाधान की तरह लग रहा था, हालांकि कीड़े के एक जोड़े हैं। 1, टेक्स्टफील्ड ऊपर जाता है लेकिन जब मैं इसमें लिखना शुरू करता हूं तो यह थोड़ा और ऊपर कूद जाता है। 2, लैंडस्केप में जब टेक्स्ट टाइप करें तो कभी-कभी बाईं ओर कूदता है।

— डैरेन

@Darren मैं इन बगों का पता लगाने की कोशिश कर रहा हूं, लेकिन मुझे नहीं मिला है, क्या आप बता सकते हैं कि आपको ये कीड़े कहां मिले हैं, जिसका मतलब है कि मैं किस संस्करण / डिवाइस के लिए ... ??

— सैफान नदाफ

Answer 11

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

class SomeClassVC: UIViewController {

  //MARK: - Lifecycle
  override func viewDidLoad() {
    super.viewDidLoad()

    addKeyboardObservers()
  }

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

    removeKeyboardObservers()
  }

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

  //MARK: - Help
  func addKeyboardObservers() {
    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)
  }

  func removeKeyboardObservers() {
    NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIKeyboardWillShow, object: self.view.window)
    NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIKeyboardWillHide, object: self.view.window)
  }

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

  func keyboardWillHide(notification: NSNotification) {
    UIView.animate(withDuration: 0.1, animations: { () -> Void in
      self.view.window?.frame.origin.y = 0
      self.view.layoutIfNeeded()
    })
  }

  func resignTextFieldFirstResponders() {
    for textField in self.view.subviews where textField is UITextField {
      textField.resignFirstResponder()
    }
  }

  func resignAllFirstResponders() {
      view.endEditing(true)
  }
}

Comments

पावले के समाधान से प्रेरित होकर, मैंने इसे स्वचालित रूप से कीबोर्ड को शेष उपलब्ध स्थान के एक निश्चित प्रतिशत से ऊपर उठाने के लिए उन्नत किया और उचित लेआउट के लिए पुनरावर्ती रूप से केंद्रित क्षेत्र भी खोजा। इसे यहाँ पकड़ो: gist.github.com/noordawod/24d32b2ce8363627ea73d7e5991009a0

— Noor Dawod

मेरा टैब बार भी विंडो के साथ आगे बढ़ रहा है! :(

— अल्फी

Answer 12

मान्य उत्तर टेक्स्टफील्ड स्थिति को ध्यान में नहीं रखता है और इसमें कुछ बग (डबल विस्थापन, प्राथमिक स्थिति में कभी वापस नहीं आते हैं, भले ही टेक्सफील्ड दृश्य के शीर्ष पर हो ...)

विचार यह है:

• ध्यान केंद्रित करने के लिए TextField को पूर्ण Y स्थिति प्राप्त करें
• कीबोर्ड ऊंचाई पाने के लिए
• पटकथा पाने के लिए
• फिर कीबोर्ड स्थिति और टेक्स्टफील्ड के बीच की दूरी की गणना करें (यदि <0 -> दृश्य ऊपर ले जाएं)
• UIView.rans.origin.y - = .. के बजाय UIView.transform का उपयोग करने के लिए, क्योंकि इससे UIView.transform = .identity के साथ मूल स्थिति में वापस आना आसान है।

तब हम दृश्य को केवल तभी स्थानांतरित कर पाएंगे जब आवश्यक हो और ओडर में विशिष्ट विस्थापन कीबोर्ड के ऊपर केंद्रित टेक्सफिल्ड के लिए हो

यहाँ कोड है:

स्विफ्ट 4

class ViewController: UIViewController, UITextFieldDelegate {

var textFieldRealYPosition: CGFloat = 0.0

override func viewDidLoad() {
    super.viewDidLoad()

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

  // Delegate all textfields

}


@objc func keyboardWillShow(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        let distanceBetweenTextfielAndKeyboard = self.view.frame.height - textFieldRealYPosition - keyboardSize.height
        if distanceBetweenTextfielAndKeyboard < 0 {
            UIView.animate(withDuration: 0.4) {
                self.view.transform = CGAffineTransform(translationX: 0.0, y: distanceBetweenTextfielAndKeyboard)
            }
        }
    }
}


@objc func keyboardWillHide(notification: NSNotification) {
    UIView.animate(withDuration: 0.4) {
        self.view.transform = .identity
    }
}


func textFieldDidBeginEditing(_ textField: UITextField) {
  textFieldRealYPosition = textField.frame.origin.y + textField.frame.height
  //take in account all superviews from textfield and potential contentOffset if you are using tableview to calculate the real position
}

}

Comments

बहुत अच्छा! (ViewDidLoad में आपके पास केवल "ViewController" के बजाय "VehiculeViewController" है।

— नवीनीकरण

एक बहुत अधिक पूर्ण और उपयोगी उत्तर। धन्यवाद! मेरा सुझाव है कि कीबोर्ड चेक को इस प्रकार कहा जाता है क्योंकि यह कीबोर्ड का एक सुसंगत आकार देगा ......... यदि कीबोर्ड को सूचित करें = (notification.userInfo? [UIResponder.keyboardFrameEndUserInfoKey? NSValue)? CgRectValue .साइज़

— बेन

Answer 13

मैंने देखा कि अन्य उत्तरों में दृश्य में से कुछ को काटना शामिल था। यदि आप किसी भी सामग्री को काटे बिना केवल दृश्य का आकार बदलना चाहते हैं, तो बस इस विधि की कोशिश करें :)

func keyboardWillShow(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
        self.view.setTranslatesAutoresizingMaskIntoConstraints(true)
        self.view.frame = CGRectMake(self.view.frame.origin.x, self.view.frame.origin.y, self.view.frame.size.width, self.view.frame.height - keyboardSize.height)
    }
}

func keyboardWillHide(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
        self.collectionView.setTranslatesAutoresizingMaskIntoConstraints(false)
        self.view.frame = CGRectMake(self.view.frame.origin.x, self.view.frame.origin.y, self.view.frame.size.width, self.view.frame.height + keyboardSize.height)
    }
}

Answer 14

शुरुआती लोगों के लिए मेरे दो सेंट: ऊपर के नमूनों में कोई व्यक्ति निर्देशांक बदलता है, अन्य "ऑटोरेर्साइजिंग मास्क", और अन्य बाधाओं का उपयोग करता है:

जैसा कि Apple कहता है, इन 3 प्रकार के तर्कों को न मिलाएं। यदि आपके पास स्टोरीबोर्ड में बाधाएं हैं, तो x / y को बदलने की कोशिश न करें। यह निश्चित रूप से काम नहीं करता है।

Answer 15

इसलिए अन्य कोई भी उत्तर सही नहीं लगता है।

आईओएस पर अच्छा व्यवहार कीबोर्ड चाहिए:

• कीबोर्ड के आकार बदलने पर स्वचालित रूप से आकार बदलें (हाँ आईटी कर सकते हैं)
• कीबोर्ड के समान गति पर चेतन
• कीबोर्ड के समान वक्र का उपयोग करके चेतन
• प्रासंगिक होने पर सुरक्षित क्षेत्रों का सम्मान करें।
• IPad / Undocked मोड पर भी काम करता है

मेरा कोड NSLayoutConstraintघोषित के रूप में उपयोग करता है@IBOutlet

@IBOutlet private var bottomLayoutConstraint: NSLayoutConstraint!

आप ट्रांसफ़ॉर्म का उपयोग भी कर सकते हैं, ऑफ़सेट देख सकते हैं, .... मुझे लगता है कि बाधा के साथ यह आसान है। यह नीचे की ओर एक अवरोध स्थापित करके काम करता है, आपको कोड को बदलने की आवश्यकता हो सकती है यदि आपका निरंतर 0 / नीचे नहीं है।

यहाँ कोड है:

// In ViewDidLoad
    NotificationCenter.default.addObserver(self, selector: #selector(?MyViewController.keyboardDidChange), name: UIResponder.keyboardWillChangeFrameNotification, object: nil)


@objc func keyboardDidChange(notification: Notification) {
    let userInfo = notification.userInfo! as [AnyHashable: Any]
    let endFrame = (userInfo[UIResponder.keyboardFrameEndUserInfoKey] as! NSValue).cgRectValue
    let animationDuration = userInfo[UIResponder.keyboardAnimationDurationUserInfoKey] as! NSNumber
    let animationCurve = userInfo[UIResponder.keyboardAnimationCurveUserInfoKey] as! NSNumber
    bottomLayoutConstraint.constant = view.frame.height - endFrame.origin.y - view.safeAreaInsets.bottom // If your constraint is not defined as a safeArea constraint you might want to skip the last part.
    // Prevents iPad undocked keyboard.
    guard endFrame.height != 0, view.frame.height == endFrame.height + endFrame.origin.y else {
        bottomLayoutConstraint.constant = 0
        return
    }
    UIView.setAnimationCurve(UIView.AnimationCurve(rawValue: animationCurve.intValue)!)
    UIView.animate(withDuration: animationDuration.doubleValue) {
        self.view.layoutIfNeeded()
        // Do additional tasks such as scrolling in a UICollectionView
    }
}

Answer 16

सभी 100 अद्यतन के लिए एकदम सही उत्तर सभी कीबोर्ड अद्यतन तालिका खोलने पर ऊंचाई

Swift4.2 के लिए

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

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

   @objc func keyboardWillShow(notification: NSNotification) {
    if ((notification.userInfo?[UIResponder.keyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue) != nil {

        var userInfo = notification.userInfo!
        var keyboardFrame:CGRect = (userInfo[UIResponder.keyboardFrameEndUserInfoKey] as! NSValue).cgRectValue
        keyboardFrame = self.view.convert(keyboardFrame, from: nil)

        var contentInset:UIEdgeInsets = self.tbl.contentInset
          contentInset.bottom = keyboardFrame.size.height
          self.tbl.contentInset = contentInset
    }
}

   @objc func keyboardWillHide(notification: NSNotification) {
    if ((notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue) != nil {
        let contentInset:UIEdgeInsets = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)
        self.tbl.contentInset = contentInset
    }
}

Swift3.2

    override func viewDidLoad() {
          super.viewDidLoad()

           NotificationCenter.default.addObserver(self, selector: #selector(RecipeVC.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)

           NotificationCenter.default.addObserver(self, selector: #selector(RecipeVC.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
    }
    func keyboardWillShow(notification: NSNotification) {
         if ((notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue) != nil {
         //self.view.frame.origin.y -= keyboardSize.height
         var userInfo = notification.userInfo!
         var keyboardFrame:CGRect = (userInfo[UIKeyboardFrameEndUserInfoKey] as! NSValue).cgRectValue
          keyboardFrame = self.view.convert(keyboardFrame, from: nil)

          var contentInset:UIEdgeInsets = self.tbl.contentInset
          contentInset.bottom = keyboardFrame.size.height
          self.tbl.contentInset = contentInset

       }
    }

    func keyboardWillHide(notification: NSNotification) {
         if ((notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue) != nil {
         let contentInset:UIEdgeInsets = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)
         self.tbl.contentInset = contentInset
         }
    }

Comments

यह सबसे अच्छा जवाब है। tbl को tableView होना चाहिए और मैंने कुछ पैडिंग जोड़ी: contentInset.bottom = keyboardFrame.size.height + 10

— iphaaw

Answer 17

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

func textFieldDidBeginEditing(_ textField: UITextField) { // became first responder

    //move textfields up
    let myScreenRect: CGRect = UIScreen.main.bounds
    let keyboardHeight : CGFloat = 216

    UIView.beginAnimations( "animateView", context: nil)
    var movementDuration:TimeInterval = 0.35
    var needToMove: CGFloat = 0

    var frame : CGRect = self.view.frame
    if (textField.frame.origin.y + textField.frame.size.height + UIApplication.shared.statusBarFrame.size.height > (myScreenRect.size.height - keyboardHeight - 30)) {
        needToMove = (textField.frame.origin.y + textField.frame.size.height + UIApplication.shared.statusBarFrame.size.height) - (myScreenRect.size.height - keyboardHeight - 30);
    }

    frame.origin.y = -needToMove
    self.view.frame = frame
    UIView.commitAnimations()
}

func textFieldDidEndEditing(_ textField: UITextField) {
    //move textfields back down
    UIView.beginAnimations( "animateView", context: nil)
    var movementDuration:TimeInterval = 0.35
    var frame : CGRect = self.view.frame
    frame.origin.y = 0
    self.view.frame = frame
    UIView.commitAnimations()
}

Answer 18

स्विफ्ट 4:

मुझे सबसे अधिक स्वीकृत उत्तर के साथ एक समस्या हो रही थी, जिसमें कीबोर्ड को छिपाने से पृष्ठ के निचले भाग में केवल (केवल आंशिक रूप से) दृश्य वापस नहीं आया। इसने मेरे लिए काम किया (+ स्विफ्ट 4 के लिए अपडेट किया गया)।

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

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

@objc func keyboardWillHide(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        if self.view.frame.origin.y != 0{
            self.view.frame.origin.y = 0
        }
    }
}

Comments

क्या होगा अगर मेरा टेक्स्टफिल्ड दृश्य के ऊपर है ..? मेरा मतलब है अगर मूल Y = 0 के साथ टेक्स्टफील्ड है .. ?? तब

— टेक्स्टफिल्ड

Answer 19

@ बोरिस जवाब के समान, लेकिन स्विफ्ट 5 में :

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

@IBAction 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 -= keyboardSize.height
        }
    }
}

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

Answer 20

यहाँ मेरा समाधान है (वास्तव में यह कोड उस स्थिति के लिए है जब आपके पास कुछ टेक्स्टफिल्ड हैं, यह उस स्थिति के लिए भी काम करता है जब आपके पास एक टेक्स्टफील्ड हो)

class MyViewController: UIViewController, UITextFieldDelegate {

@IBOutlet weak var firstTextField: UITextField!
@IBOutlet weak var secondTextField: UITextField!

var activeTextField: UITextField!
var viewWasMoved: Bool = false


override func viewDidLoad() {
    super.viewDidLoad()
    NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(PrintViewController.keyboardWillShow(_:)), name: UIKeyboardWillShowNotification, object: nil)
    NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(PrintViewController.keyboardWillHide(_:)), name: UIKeyboardWillHideNotification, object: nil)
}

override func viewDidDisappear(animated: Bool) {
    super.viewWillDisappear(animated)
    NSNotificationCenter.defaultCenter().removeObserver(self)
}

func textFieldDidBeginEditing(textField: UITextField) {
    self.activeTextField = textField
}

func textFieldDidEndEditing(textField: UITextField) {
    self.activeTextField = nil
}

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


func keyboardWillShow(notification: NSNotification) {

    let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue()

    var aRect: CGRect = self.view.frame
    aRect.size.height -= keyboardSize!.height

    let activeTextFieldRect: CGRect? = activeTextField?.frame
    let activeTextFieldOrigin: CGPoint? = activeTextFieldRect?.origin

    if (!CGRectContainsPoint(aRect, activeTextFieldOrigin!)) {
        self.viewWasMoved = true
        self.view.frame.origin.y -= keyboardSize!.height
    } else {
        self.viewWasMoved = false
    }
}

func keyboardWillHide(notification: NSNotification) {
    if (self.viewWasMoved) {
        if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
            self.view.frame.origin.y += keyboardSize.height
        }
    }
}

Comments

TextFields के लिए प्रतिनिधि सेट करने के लिए मत भूलना

— SwingerDinger

Keyboardwills में स्थिति को इस प्रकार बदलें, यदि (! CGRectContainsPoint (aRect, newOrgin!) और&!

— Self.viewWasMoved

add self.viewWasMoved = false जब आप फ्रेम को रीसेट कर रहे हैं

— KingofBliss

Answer 21

स्विफ्ट 3 के लिए अपडेट किया गया ...

जैसा कि अन्य लोगों ने कहा है, आपको अपने नियंत्रक के दृष्टिकोण में अधिसूचना पर्यवेक्षकों को जोड़ने की आवश्यकता है () विधि, जैसे:

NotificationCenter.default.addObserver(forName: .UIKeyboardWillShow, object: nil, queue: nil)
    { notification in
    self.keyboardWillShow(notification)
    }

NotificationCenter.default.addObserver(forName: .UIKeyboardWillHide, object: nil, queue: nil)
    { notification in
    self.keyboardWillHide(notification)
    }

NotificationCenter.default.addObserver(forName: .UIKeyboardDidShow, object: nil, queue: nil)
    { _ in
    self.enableUserInteraction()
    }

NotificationCenter.default.addObserver(forName: .UIKeyboardDidHide, object: nil, queue: nil)
    { _ in
    self.enableUserInteraction()
    }

अपने पर्यवेक्षकों को हटाने के लिए याद रखें जहां उपयुक्त है (मैं इसे व्यूविलडिसएपियर () विधि में करता हूं)

NotificationCenter.default.removeObserver(self, name: .UIKeyboardWillShow, object: nil)
NotificationCenter.default.removeObserver(self, name: .UIKeyboardWillHide, object: nil)
NotificationCenter.default.removeObserver(self, name: .UIKeyboardDidShow, object: nil)
NotificationCenter.default.removeObserver(self, name: .UIKeyboardDidHide, object: nil)

फिर, अपने शो को लागू करें और तरीकों को छिपाएं - एप्लिकेशन को बताएं कि एप्लिकेशन को इंटरैक्शन इवेंट्स को अनदेखा करने के लिए कहता है (startIgnoringInteractionEvents)। यह महत्वपूर्ण है क्योंकि इसके बिना, उपयोगकर्ता एक क्षेत्र या यहां तक ​​कि एक स्क्रॉलव्यू पर टैप कर सकता है और दूसरी बार शिफ्ट होने का कारण बन सकता है, जिसके परिणामस्वरूप एक भयानक यूआई गड़बड़ है। कीबोर्ड दिखाने से पहले बातचीत की घटनाओं को अनदेखा करना और इसे छिपाना छिप जाएगा:

func keyboardWillShow(notification: Notification)
    {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue
        {
        UIApplication.shared.beginIgnoringInteractionEvents()
        self.view.frame.origin.y -= keyboardSize.height
        // add this line if you are shifting a scrollView, as in a chat application
        self.timelineCollectionView.contentInset.top += keyboardSize.height
        }
    }

func keyboardWillHide(notification: Notification)
    {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue
        {
        UIApplication.shared.beginIgnoringInteractionEvents()
        self.view.frame.origin.y += keyboardSize.height
        // add this line if you are shifting a scrollView, as in a chat application
        self.timelineCollectionView.contentInset.top -= keyboardSize.height
        }
    }

अंत में, उपयोगकर्ता इंटरैक्शन को फिर से सक्षम करें (याद रखें, यह विधि कीबोर्ड के बाद फायर करता हैशो या हाइड):

func enableUserInteraction()
    {
    UIApplication.shared.endIgnoringInteractionEvents()
    }

Answer 22

स्विफ्ट 3 कोड

var activeField: UITextField?

override func viewDidLoad() {
    super.viewDidLoad()

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

func textFieldDidBeginEditing(_ textField: UITextField){
    activeField = textField
}

func textFieldDidEndEditing(_ textField: UITextField){
    activeField = nil
}

func keyboardWillShow(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
        if (self.activeField?.frame.origin.y)! >= keyboardSize.height {
            self.view.frame.origin.y = keyboardSize.height - (self.activeField?.frame.origin.y)!
        } else {
            self.view.frame.origin.y = 0
        }
    }
}

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

Answer 23

यदि आपके पास एक ही वीसी पर 2 या अधिक पाठ फ़ील्ड हैं, और उपयोगकर्ता उनमें से एक पर टैप करता है और फिर दूसरे पर टैप करता है, तो बिना फ़ंक्शन कीबोर्डविलीहेड को कॉल किए, दृश्य एक बार और ऊपर जा रहा है, जो आवश्यक नहीं है, क्योंकि आपके पास कीबोर्ड, एक रिक्त स्थान होगा जिसमें कीबोर्ड की ऊंचाई होगी, और फिर दृश्य, जो मैंने संपादित उत्तर में कोड का उपयोग किया है:

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

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

func keyboardWillHide(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
        self.view.frame.origin.y += keyboardSize.height
    }
}

इसे हल करने के लिए, इन दोनों कार्यों "KeyboardWillShow / Hide" को बदलें:

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

func keyboardWillHide(notification: NSNotification) {
    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
        if view.frame.origin.y != 0 {
            self.view.frame.origin.y += keyboardSize.height
        }
    }
}

Comments

क्या होगा अगर मेरा टेक्स्टफिल्ड दृश्य के ऊपर है ..? मेरा मतलब है अगर मूल Y = 0 के साथ टेक्स्टफील्ड है .. ?? तब

— टेक्स्टफिल्ड

Answer 24

@ बोरिस का समाधान बहुत अच्छा है लेकिन दृश्य कभी-कभी दूषित हो सकता है।

सही संरेखण के लिए, नीचे दिए गए कोड का उपयोग करें

override func viewDidLoad() {
super.viewDidLoad()            
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)}

कार्य:

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

तथा,

@objc func keyboardWillHide(notification: NSNotification) {
if let keyboardSize = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
    if self.view.frame.origin.y != 0{
        self.view.frame.origin.y = 0 
    }
} }

Answer 25

यह वीडियो ट्यूटोरियल सबसे अच्छा है। 7 मिनट लंबा और यह सिर्फ इतना समझ में आता है। जब आपके पास एक से अधिक टेक्स्ट फ़ील्ड हों, तो इस तरह का एक सरल समाधान चाहते हैं और उस विशिष्ट टेक्स्टफ़ील्ड को टैप करने पर स्क्रॉल दृश्य "x" राशि पिक्सेल पर ले जाना चाहते हैं।

https://youtu.be/VuiPGJOEBH4

बस ये कदम:

एक स्क्रॉलव्यू के भीतर अपने सभी टेक्स्ट फील्ड्स को देखें जो दृश्य के किनारों पर विवश हैं।

-सभी टेक्स्टफिल्ड्स को स्क्रॉल करें और व्यू कंट्रोलर को डेलिगेट्स के रूप में स्क्रॉल करें।

-सभी टेक्स्टफिल्ड को कनेक्ट करें और एक IBOutlet के साथ स्क्रॉल देखें।

class ViewController: UIViewController, UITextFieldDelegate {

अपनी कक्षा में UITextFieldDelegate प्रोटोकॉल जोड़ें

@IBOutlet var stateAddress: UITextField!
@IBOutlet var zipAddress: UITextField!
@IBOutlet var phoneNumber: UITextField!
@IBOutlet var vetEmailAddress: UITextField!    
@IBOutlet weak var scrollView: UIScrollView!

अपनी स्विफ्ट फ़ाइल में UITextFieldDelegate तरीके जोड़ें:

func textFieldShouldReturn(textField: UITextField) -> Bool {

    textField.resignFirstResponder()
    return true
}


func textFieldDidBeginEditing(textField: UITextField) {

    if (textField == self.stateAddress) {
        scrollView.setContentOffset(CGPointMake(0, 25), animated: true)
    }
    else if (textField == self.zipAddress) {
        scrollView.setContentOffset(CGPointMake(0, 57), animated: true)
    }
    else if (textField == self.phoneNumber) {
        scrollView.setContentOffset(CGPointMake(0, 112), animated: true)
    }
    else if (textField == self.vetEmailAddress) {
        scrollView.setContentOffset(CGPointMake(0, 142), animated: true)
    }
}

func textFieldDidEndEditing(textField: UITextField) {

    scrollView.setContentOffset(CGPointMake(0, 0), animated: true)
}

पहला तरीका कीबोर्ड को खारिज करने के लिए कीबोर्ड पर रिटर्न बटन को सक्रिय करता है। दूसरा वह है जब आप जो भी विशिष्ट टेक्स्टफील्ड में टैप करते हैं, उसके बाद y को सेट करते हैं कि आपका स्क्रॉलव्यू स्क्रॉल कितना दूर है (मेरा मेरे कंट्रोलर 25,57,112,142 पर y स्थान से दूर है)। आखिरी कहता है जब आप कीबोर्ड से दूर टैप करते हैं तो स्क्रॉलव्यू मूल स्थान पर वापस चला जाता है।

मैंने अपने विचार पिक्सेल को इस तरह से परिपूर्ण बनाया!

Answer 26

यह फीचर शू इओस में बनाया गया है, हालांकि हमें बाहरी रूप से करने की जरूरत है।
नीचे दिए गए कोड को सम्मिलित करें
* जब टेक्स्टफिल्ड कीबोर्ड के नीचे है,
तो देखने के लिए , * जब कीबोर्ड के ऊपर टेक्स्टफिल्ड हो तो दृश्य को स्थानांतरित करने के लिए नहीं। *
जरूरत के समय कीबोर्ड की ऊंचाई के आधार पर दृश्य को स्थानांतरित करने के लिए।
यह सभी मामलों में काम करता है और परीक्षण किया जाता है।

import UIKit

class NamVcc: UIViewController, UITextFieldDelegate
{
    @IBOutlet weak var NamTxtBoxVid: UITextField!

    var VydTxtBoxVar: UITextField!
    var ChkKeyPadDspVar: Bool = false
    var KeyPadHytVal: CGFloat!

    override func viewDidLoad()
    {
        super.viewDidLoad()

        NamTxtBoxVid.delegate = self
    }

    override func viewWillAppear(animated: Bool)
    {
        NSNotificationCenter.defaultCenter().addObserver(self,
            selector: #selector(TdoWenKeyPadVyd(_:)),
            name:UIKeyboardWillShowNotification,
            object: nil);
        NSNotificationCenter.defaultCenter().addObserver(self,
            selector: #selector(TdoWenKeyPadHyd(_:)),
            name:UIKeyboardWillHideNotification,
            object: nil);
    }

    func textFieldDidBeginEditing(TxtBoxPsgVar: UITextField)
    {
        self.VydTxtBoxVar = TxtBoxPsgVar
    }

    func textFieldDidEndEditing(TxtBoxPsgVar: UITextField)
    {
        self.VydTxtBoxVar = nil
    }

    func textFieldShouldReturn(TxtBoxPsgVar: UITextField) -> Bool
    {
        self.VydTxtBoxVar.resignFirstResponder()
        return true
    }

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

    func TdoWenKeyPadVyd(NfnPsgVar: NSNotification)
    {
        if(!self.ChkKeyPadDspVar)
        {
            self.KeyPadHytVal = (NfnPsgVar.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue().height

            var NonKeyPadAraVar: CGRect = self.view.frame
            NonKeyPadAraVar.size.height -= self.KeyPadHytVal

            let VydTxtBoxCenVal: CGPoint? = VydTxtBoxVar?.frame.origin

            if (!CGRectContainsPoint(NonKeyPadAraVar, VydTxtBoxCenVal!))
            {
                self.ChkKeyPadDspVar = true
                UIView.animateWithDuration(1.0,
                    animations:
                    { self.view.frame.origin.y -= (self.KeyPadHytVal)},
                    completion: nil)
            }
            else
            {
                self.ChkKeyPadDspVar = false
            }
        }

    }

    func TdoWenKeyPadHyd(NfnPsgVar: NSNotification)
    {
        if (self.ChkKeyPadDspVar)
        {
            self.ChkKeyPadDspVar = false
            UIView.animateWithDuration(1.0,
                animations:
                { self.view.frame.origin.y += (self.KeyPadHytVal)},
                completion: nil)
        }
    }

    override func viewDidDisappear(animated: Bool)
    {
        super.viewWillDisappear(animated)
        NSNotificationCenter.defaultCenter().removeObserver(self)
        view.endEditing(true)
        ChkKeyPadDspVar = false
    }
}

---

| :: | कभी-कभी View wil डाउन हो जाता है, उस स्थिति में ऊंचाई +/- 150 का उपयोग करें:

    NonKeyPadAraVar.size.height -= self.KeyPadHytVal + 150

    { self.view.frame.origin.y -= self.KeyPadHytVal  - 150},
                    completion: nil)

    { self.view.frame.origin.y += self.KeyPadHytVal  - 150},
                completion: nil)

Answer 27

func keyboardWillShow(notification: NSNotification) {

    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
        self.view.frame.origin.y = self.view.frame.height - (self.view.frame.height + keyboardSize.height)
    }

}

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

यह अधिक स्थिर होना चाहिए

Answer 28

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

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

 }

 // MARK: - keyboard
 func keyboardWillShow(notification: NSNotification) 
{

if let userInfo = notification.userInfo {
if let keyboardSize = (userInfo[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
let contentInsets = self.tblView.contentInset as UIEdgeInsets
self.tblView.contentInset = UIEdgeInsets(top: contentInsets.top, left: contentInsets.left, bottom: keyboardSize.height, right:contentInsets.right)
                    // ...
                } else {
                    // no UIKeyboardFrameBeginUserInfoKey entry in userInfo
                }
            } else {
                // no userInfo dictionary in notification
            }
        }

func keyboardWillHide(notification: NSNotification) 
{
let contentInsets = self.tblView.contentInset as UIEdgeInsets
self.tblView.contentInset = UIEdgeInsets(top: contentInsets.top, left: contentInsets.left, bottom: 0, right:contentInsets.right)
 }

Answer 29

UITextField पर क्लिक किए गए दृश्य के लिए निम्न कोड का उपयोग करें

func textFieldDidBeginEditing(textField: UITextField) {
    ViewUpanimateMoving(true, upValue: 100)
}
func textFieldDidEndEditing(textField: UITextField) {
    ViewUpanimateMoving(false, upValue: 100)
}
func ViewUpanimateMoving (up:Bool, upValue :CGFloat){
    var durationMovement:NSTimeInterval = 0.3
    var movement:CGFloat = ( up ? -upValue : upValue)
    UIView.beginAnimations( "animateView", context: nil)
    UIView.setAnimationBeginsFromCurrentState(true)
    UIView.setAnimationDuration(durationMovement)
    self.view.frame = CGRectOffset(self.view.frame, 0,  movement)
    UIView.commitAnimations()
}

Answer 30

मैंने बात को आसान बनाने के लिए एक कोकोपॉड बनाया:

https://github.com/xtrinch/KeyboardLayoutHelper

इसे कैसे उपयोग करे:

एक ऑटो लेआउट नीचे की ओर बनायें, इसे KeyboardLayoutCelstraint की एक क्लास दें । उदाहरणों पर उदाहरण परियोजना देखें कि इसे कैसे उपयोग किया जाए (मैंने दो बनाए: एक स्क्रॉल दृश्य के अंदर textFields, और दो मूल विचारों के साथ लंबवत केंद्रित textFields - लॉगिन और रजिस्टर)।

निचला लेआउट बाधा कंटेनर दृश्य का हो सकता है, टेक्स्टफिल्ड स्वयं, कुछ भी, आप इसे नाम देते हैं।