Move textfield when keyboard appears swift

If you're using Auto Layout, I assume you've set the Bottom Space to Superview constraint. If that's the case, you simply have to update the constraint's value. Here's how you do it with a little bit of animation.

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

The hardcoded 20 is added only to pop the textfield above the keyboard just a bit. Otherwise the keyboard's top margin and textfield's bottom margin would be touching.

When the keyboard is dismissed, reset the constraint's value to its original one.

A simple solution is to move view up with constant of keyboard height.

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 } 

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

For moving your view while editing textfield try this , I have applied this ,

Option 1 :- ** **Update in Swift 5.0 and iPhone X , XR , XS and XS Max Move using NotificationCenter

• Register this Notification in func viewWillAppear(_ animated: Bool)

• Deregister this Notification in func viewWillDisappear(_ animated: Bool)

Note:- If you will not deregister than it will call from child class and will reason of crashing or else.

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

Option 2 :- Its work fine

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

I got this answer from this source UITextField move up when keyboard appears in Swift

IN the Swift 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() } 

I love clean Swift code. So here's the tightest code I could come up with to move a text view up/down with the keyboard. It's currently working in an iOS8/9 Swift 2 production app.

UPDATE (March 2016): I just tightened up my previous code as much as possible. Also, there are a bunch of popular answers here that hardcode the keyboard height and animation parameters. There's no need for that, not to mention that the numbers in these answers don't always line up with the actual values I'm seeing on my 6s+ iOS9 (keyboard height of 226, duration of 0.25, and animation curve of 7). In any case, it's almost no extra code to get those values straight from the system. See below.

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

NOTE: This code covers the most comment/general case. However, more code may be needed to handle different orientations and/or custom keyboards Here's an in-depth article on working with the iOS keyboard. If you need to handle every scenario, this may help.

Edit: I recommend an easier and cleaner solution. Just change the class of bottom spacing constraint to KeyboardLayoutConstraint. It will automatically expand to the keyboard height.

This is an improved version of @JosephLord 's answer.

As tested on iOS 8.3 iPad Simulator, Portrait. Xcode6.3 beta4, I found his answer doesn't work when keyboard is hiding because UIKeyboardFrameEndUserInfoKey is "NSRect: {{0, 1024}, {768, 264}}";. The height is never 0.

This goes back to use the traditional UIKeyboardWillShowNotification and UIKeyboardWillHideNotification to better tell when keyboard is hiding rather than relying on the end frame's height. UIKeyboardWillShowNotification is also sent when keyboard frame is changed so it should cover all use cases.

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

i am working with swift 4 and i am solved this issue without use any extra bottom constraint look my code is here.its really working on my case

1) Add Notification Observer in did load

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) Remove Notification Observer like

deinit { NotificationCenter.default.removeObserver(self) } 

3) Add keyboard show/ hide methods like

 @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) Add textfeild delegate and add touchesBegan methods .usefull for hide the keyboard when touch outside the textfeild on screen

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

You can use this library and just one line of code in appDidFinishedLaunching and u are done..

func application(application: UIApplication,didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool { IQKeyboardManager.sharedManager().enable = true return true } 

IQKeyboardManager - adjust view whenever keyboard appear link - https://github.com/hackiftekhar/IQKeyboardManager

This is an improved version of @JosephLord and @Hlung's answer. It can apply whether you have tabbar or not. And it would perfectly restore view that is moved by keyboard to original position.

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

I created a Swift 3 protocol to handle the keyboard appearance / disappearance

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

Then, to implement it in a UIViewController, do the following:

• let the viewController conform to this protocol :

  class FormMailVC: UIViewControlle, KeyboardHandler { 

• start observing keyboard changes in viewWillAppear:

  // MARK: - View controller life cycle override func viewWillAppear(_ animated: Bool) { super.viewWillAppear(animated) startObservingKeyboardChanges() } 

• stop observing keyboard changes in viewWillDisappear:

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

• create an IBOutlet for the bottom constraint from the storyboard:

  // NSLayoutConstraints @IBOutlet weak var bottomConstraint: NSLayoutConstraint! 

  (I recommend having all of your UI embedded inside a "contentView", and linking to this property the bottom constraint from this contentView to the bottom layout guide)

• change the constraint priority of the top constraint to 250 (low)

This is to let the whole content view slide upwards when the keyboard appears. The priority must be lower than any other constraint priority in the subviews, including content hugging priorities / content compression resistance priorities.

• Make sure that your Autolayout has enough constraints to determine how the contentView should slide up.

You may have to add a "greater than equal" constraint for this:

And here you go!

Complete code for managing keyboard.

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

Easiest way that doesn't require any code:

1. Download KeyboardLayoutConstraint.swift and add (drag & drop) the file into your project, if you're not using the Spring animation framework already.
2. In your storyboard, create a bottom constraint for the object/view/textfield, select the constraint (double-click it) and in the Identity Inspector, change its class from NSLayoutConstraint to KeyboardLayoutConstraint.
3. Done!

The object will auto-move up with the keyboard, in sync.

Such simple UIViewController extension can be used

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

Example of usage

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

Swift 4 solution

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

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

A Swift 5 solution for frédéric-adda :

 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: UIResponder.keyboardWillShowNotification, object: nil, queue: nil) { [weak self] notification in self?.keyboardWillShow(notification) } // Deal with rotations NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillChangeFrameNotification, object: nil, queue: nil) { [weak self] notification in self?.keyboardWillShow(notification) } // Deal with keyboard change (emoji, numerical, etc.) NotificationCenter.default.addObserver(forName: UITextInputMode.currentInputModeDidChangeNotification, object: nil, queue: nil) { [weak self] notification in self?.keyboardWillShow(notification) } NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillHideNotification, 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?[UIResponder.keyboardFrameEndUserInfoKey] 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) } } 

In any UIViewController:

• Conform to KeyboardHandler protocol

extension AnyViewController: KeyboardHandler {} 

• Add bottom constraint for the last-bottom element on the screen.

@IBOutlet var bottomConstraint: NSLayoutConstraint! 

• Add Observer subscribe/unsubscribe:

 override func viewWillAppear(_ animated: Bool) { super.viewWillAppear(animated) startObservingKeyboardChanges() } override func viewWillDisappear(_ animated: Bool) { super.viewWillDisappear(animated) stopObservingKeyboardChanges() } 

Enjoy!

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

And Lastly since we are using delegates methods

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

refactored from using objective-c http://www.cocoawithlove.com/2008/10/sliding-uitextfields-around-to-avoid.html

Another solution that doesn't depend on autolayout, constraints or any outlets. What you do need is your field(s) in a scrollview.

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

Here is my version for a solution for Swift 2.2:

First register for Keyboard Show/Hide Notifications

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

Then in methods coresponding for those notifications move the main view up or down

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 } 

The trick is in the "keyboardWillShow" part which get calls every time "QuickType Suggestion Bar" is expanded or collapsed. Then we always set the y coordinate of the main view which equals the negative value of total keyboard height (with or without the "QuickType bar" portion).

At the end do not forget to remove observers

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

The following is a simple solution, whereby the text field has a constraint tying it to the bottom layout guide. It simply adds the keyboard height to the constraint's constant.

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

Well, I think i might be too late but i found another simple version of Saqib's answer. I'm using Autolayout with constraints. I have a small view inside of another main view with username and password fields. Instead of changing the y coordinate of the view i'm saving the original constraint value in a variable and changing the constraint's constant to some value and again after the keyboard dismisses, i'm setting up the constraint to original one. This way it avoids the problem Saqib's answer has, (The view keeps on moving up and does not stop). Below is my code...

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 } 

Swift 4.x answer, merging answers from @Joseph Lord and @Isuru. bottomConstraint represents the bottom constraint of the view you're interested in moving.

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

Very Simple and no need to code more. Just add pod 'IQKeyboardManagerSwift' in your podfile, and in your AppDelegate page add code below.

import IQKeyboardManagerSwift 

and in method didFinishLaunchingWithOptions() type

IQKeyboardManager.shared.enable = true 

that is it. check this video link for better understanding https://youtu.be/eOM94K1ZWN8 Hope this will help you.

I have done by following manner:

This is useful when textfield superview is view

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

 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 } 

For anyone not using storyboards to set the layout constraint. This is a pure programmatic way to get it working on Swift 5:

1. Define an empty constraint in your viewController. In this case, I am building a chat app that has a UIView containing text view at the very bottom of the screen.

var discussionsMessageBoxBottomAnchor: NSLayoutConstraint = NSLayoutConstraint() 

2. In viewDidLoad add the constraints for the bottom-most view. In this case discussionsMessageBox. Also, add the listener for keyboard events.

For correctly initializing the constraint, you need to first add the subview and then define the constraint.

NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardNotification(notification:)), name: NSNotification.Name.UIKeyboardWillChangeFrame, object: nil) view.addSubview(discussionsMessageBox) if #available(iOS 11.0, *) { discussionsMessageBoxBottomAnchor = discussionsMessageBox.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor, constant: 0) } else { // Fallback on earlier versions discussionsMessageBoxBottomAnchor = discussionsMessageBox.bottomAnchor.constraint(equalTo: view.bottomAnchor, constant: 0) } NSLayoutConstraint.activate([ discussionsMessageBoxBottomAnchor ]) 

3. Define deinit.

deinit { NotificationCenter.default.removeObserver(self) } 

4. Next add the code that @JosephLord defined, with one correction to fix offset math.

extension DiscussionsViewController { @objc func keyboardNotification(notification: NSNotification) { guard let userInfo = notification.userInfo else { return } 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 ?? UIView.AnimationOptions.curveEaseInOut.rawValue let animationCurve:UIView.AnimationOptions = UIView.AnimationOptions(rawValue: animationCurveRaw) if endFrameY >= UIScreen.main.bounds.size.height { self.discussionsMessageBoxBottomAnchor.constant = 0.0 } else { //Changed line self.discussionsMessageBoxBottomAnchor.constant = -1 * (endFrame?.size.height ?? 0.0) } UIView.animate( withDuration: duration, delay: TimeInterval(0), options: animationCurve, animations: { self.view.layoutIfNeeded() }, completion: nil) } } 

If you have more than one text field on the view, then I suggest that you look at this method. When switching between fields, you will not have a problem with the fact that the view runs away, it will simply adapt to the desired text field. It works in swift 5

 override func viewDidLoad() { super.viewDidLoad() registerForKeyboardNotification() } 

All methods in extensions

extension StartViewController: UITextFieldDelegate { func registerForKeyboardNotification() { 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) } @objc func keyboardWillShow(sender: NSNotification) { guard let userInfo = sender.userInfo, let keyboardFrame = userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue, let currentTextField = UIResponder.currentFirst() as? UITextField else { return } let keyboardTopY = keyboardFrame.cgRectValue.origin.y let convertedTextFieldFrame = view.convert(currentTextField.frame, from: currentTextField.superview) let textFieldBottomY = convertedTextFieldFrame.origin.y + convertedTextFieldFrame.size.height if textFieldBottomY > keyboardTopY { let textBoxY = convertedTextFieldFrame.origin.y let newFrameY = (textBoxY - keyboardTopY / 2) * -1 view.frame.origin.y = newFrameY } } @objc func keyboardWillHide(sender: NSNotification) { self.view.frame.origin.y = 0 } func textFieldShouldReturn(_ textField: UITextField) -> Bool { switch textField { case emailTextField : passwordTextField.becomeFirstResponder() default: emailTextField.becomeFirstResponder() } return true } override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) { super.touchesBegan(touches , with:event) view.endEditing(true) } } 

At the end we set up the method with UIResponder

extension UIResponder { private struct Static { static weak var responder: UIResponder? } static func currentFirst() -> UIResponder? { Static.responder = nil UIApplication.shared.sendAction(#selector(UIResponder._trap), to: nil, from: nil, for: nil) return Static.responder } @objc private func _trap() { Static.responder = self } } 

I have done in following manner :

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 

If you are like me who has tried all the above solutions and still your problem is not solved, I have a got a great solution for you that works like a charm. First I want clarify few things about some of solutions mentioned above.

1. In my case IQkeyboardmanager was working only when there is no auto layout applied on the elements, if it is applied then IQkeyboard manager will not work the way we think.
2. Same thing with upward movement of self.view.
3. i have wriiten a objective c header with a swift support for pushing UITexfield upward when user clicks on it, solving the problem of keyboard covering the UITextfield : https://github.com/coolvasanth/smart_keyboard.
4. One who has An intermediate or higher level in iOS app development can easily understand the repository and implement it. All the best

Here is a generic solution for all TextField Steps -

1) Create a common ViewController that is extended by other 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) Create a extension of UIViewController and the currently active TextField

//get active text field 

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

}

I modified @Simpa solution a little bit.........

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

None of them worked for and I ended up using content insets to move my view up when the keyboard appears.

Note: I was using a UITableView

Referenced solution @ keyboard-content-offset which was entirely written in objective C, the below solution is clean Swift.

Add the notification observer @ 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); 

To get the keyboard size, we first get the userInfo dictionary from the notification object, which stores any additional objects that our receiver might use.

From that dictionary we can get the CGRect object describing the keyboard’s frame by using the key UIKeyboardFrameBeginUserInfoKey.

Apply the content inset for the table view @ keyboardWillBeShown method,

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

Restore the view @ keyboardWillBeHidden method

func keyboardWillBeHidden(sender: NSNotification) { // Moving back the table view back to the default position yourTableView.contentInset = UIEdgeInsetsZero; yourTableView.scrollIndicatorInsets = UIEdgeInsetsZero; } 

If you want to keep the device orientation also into consideration, use conditional statements to tailor the code to your needs.

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