Nsryjdtyk

Here is My 2 cents:

Have you tried: https://github.com/hackiftekhar/IQKeyboardManager

Extremely easy to install Swift or Objective-C.

Here how it works:

IQKeyboardManager (Swift):- IQKeyboardManagerSwift is available through CocoaPods, to install it simply add the following line to your Podfile: (#236)

pod 'IQKeyboardManagerSwift'

In AppDelegate.swift, just import IQKeyboardManagerSwift framework and enable IQKeyboardManager.

import IQKeyboardManagerSwift



@UIApplicationMain

class AppDelegate: UIResponder, UIApplicationDelegate {



    var window: UIWindow?



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



    IQKeyboardManager.sharedManager().enable = true



    return true

    }

}

And that is all. Easy!

The one I found to work perfectly for me was this:

func textFieldDidBeginEditing(textField: UITextField) {

    if textField == email || textField == password {

        animateViewMoving(true, moveValue: 100)

    }

}



func textFieldDidEndEditing(textField: UITextField) {

    if textField == email || textField == password {

        animateViewMoving(false, moveValue: 100)

    }

}



func animateViewMoving (up:Bool, moveValue :CGFloat){

    let movementDuration:NSTimeInterval = 0.3

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

}

You can also change the height values. Remove the "if statement" if you want to use it for all text fields.

You can even use this for all controls that require user input like TextView.

Is there a way to have the screen only move when the bottom fields are edited?

I had a similar problem and found a pretty straightforward solution without using a scrollView, and instead using if statements within the keyboardWillShow/Hide methods.

func keyboardWillShow(notification: NSNotification) {

    if bottomText.editing{

        self.view.window?.frame.origin.y = -1 * getKeyboardHeight(notification)

    }

}



func keyboardWillHide(notification: NSNotification) {

    if self.view.window?.frame.origin.y != 0 {

        self.view.window?.frame.origin.y += getKeyboardHeight(notification)

    }

}

This was a good solution for me because I only had two text fields.

Shifts whole view up: only when certain text fields (bottomText) are edited

Shifts whole view down: only when the view is not at the original location

Why not implement this in a UITableViewController instead? The keyboard won't hide any text fields when its shown.

Just use this extension to move any UIView when keyboard is presented.

     extension UIView {

    func bindToKeyboard(){

        NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWillChange(_:)), name: NSNotification.Name.UIKeyboardWillChangeFrame, object: nil)

    }



    @objc func keyboardWillChange(_ notification: NSNotification){

        let duration = notification.userInfo![UIKeyboardAnimationDurationUserInfoKey] as! Double

        let curve = notification.userInfo![UIKeyboardAnimationCurveUserInfoKey] as! UInt

        let beginningFrame = (notification.userInfo![UIKeyboardFrameBeginUserInfoKey] as! NSValue).cgRectValue

        let endFrame = (notification.userInfo![UIKeyboardFrameEndUserInfoKey] as! NSValue).cgRectValue







        let deltaY = endFrame.origin.y - beginningFrame.origin.y



        UIView.animateKeyframes(withDuration: duration, delay: 0.0, options: UIViewKeyframeAnimationOptions(rawValue: curve), animations: {

            self.frame.origin.y += deltaY

        }, completion: nil)

    }

}

Then in your viewdidload bind your view to the keyboard

UiView.bindToKeyboard()

Swift 4 (**updated) with extension**

1. add the buttons in one container


2. connect bottom constraint of the container with IBOutlet containerBtmConstrain


3. 
   

   inViewDidLoad

   
   
   

   self.containerDependOnKeyboardBottomConstrain = containerBtmConstrain
   
   self.watchForKeyboard() 
   
   

   
   


4. 
   

   add the following extension

   
   
   

   import UIKit
   
   
   
   private var xoAssociationKeyForBottomConstrainInVC: UInt8 = 0
   
   
   
   extension UIViewController {
   
   
   
    var containerDependOnKeyboardBottomConstrain :NSLayoutConstraint! {
   
     get {
   
       return objc_getAssociatedObject(self, &xoAssociationKeyForBottomConstrainInVC) as? NSLayoutConstraint
   
     }
   
     set(newValue) {
   
       objc_setAssociatedObject(self, &xoAssociationKeyForBottomConstrainInVC, newValue, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN)
   
     }
   
    }
   
   
   
    func watchForKeyboard () {
   
      NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWasShown(notification:)), name:UIResponder.keyboardWillShowNotification, object: nil);
   
      NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWillHide(notification:)), name:UIResponder.keyboardWillHideNotification, object: nil);
   
    }
   
   
   
    @objc func keyboardWasShown(notification: NSNotification) {
   
     let info = notification.userInfo!
   
     let keyboardFrame: CGRect = (info[UIResponder.keyboardFrameEndUserInfoKey] as! NSValue).cgRectValue
   
   
   
     UIView.animate(withDuration: 0.3, animations: { () -> Void in
   
       self.containerDependOnKeyboardBottomConstrain.constant = -keyboardFrame.height
   
       self.view.layoutIfNeeded()
   
     })
   
    }
   
   
   
    @objc func keyboardWillHide(notification: NSNotification) {
   
       UIView.animate(withDuration: 0.3, animations: { () -> Void in
   
       self.containerDependOnKeyboardBottomConstrain.constant = 0
   
       self.view.layoutIfNeeded()
   
     })
   
    }
   
   }
   
   

   
   

I think this clause is wrong:

if (!CGRectContainsPoint(aRect, activeField!.frame.origin))

While the activeField's origin may well be above the keyboard, the maxY might not...

I would create a 'max' point for the activeField and check if that is in the keyboard Rect.

I use SwiftLint, which had a few issues with the formatting of the accepted answer. Specifically:

no space before the colon,
no force casting,
prefer UIEdgeInset(top: etc... instead of UIEdgeInsetMake.

so here are those updates for Swift 3

func registerForKeyboardNotifications() {

    //Adding notifies on keyboard appearing

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

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

}



func deregisterFromKeyboardNotifications() {

    //Removing notifies on keyboard appearing

    NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIKeyboardWillShow, object: nil)

    NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIKeyboardWillHide, object: nil)

}



func keyboardWasShown(notification: NSNotification) {

    //Need to calculate keyboard exact size due to Apple suggestions

    scrollView?.isScrollEnabled = true

    var info = notification.userInfo!

    if let keyboardSize = (info[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue.size {

        let contentInsets: UIEdgeInsets = UIEdgeInsets(top: 0.0, left: 0.0, bottom: keyboardSize.height, right: 0.0)



        scrollView?.contentInset = contentInsets

        scrollView?.scrollIndicatorInsets = contentInsets



        var aRect: CGRect = self.view.frame

        aRect.size.height -= keyboardSize.height

        if let activeField = self.activeField {

            if !aRect.contains(activeField.frame.origin) {

                self.scrollView.scrollRectToVisible(activeField.frame, animated: true)

            }

        }

    }

}



func keyboardWillBeHidden(notification: NSNotification) {

    //Once keyboard disappears, restore original positions

    var info = notification.userInfo!

    if let keyboardSize = (info[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue.size {

        let contentInsets: UIEdgeInsets = UIEdgeInsets(top: 0.0, left: 0.0, bottom: -keyboardSize.height, right: 0.0)

        scrollView?.contentInset = contentInsets

        scrollView?.scrollIndicatorInsets = contentInsets

    }



    view.endEditing(true)

    scrollView?.isScrollEnabled = false

}



func textFieldDidBeginEditing(_ textField: UITextField) {

    activeField = textField

}



func textFieldDidEndEditing(_ textField: UITextField) {

    activeField = nil

}

Here's my version after reading the documentation provided by Apple and the previous posts. One thing I noticed is that the textView was not handled when covered by the keyboard. Unfortunately, Apple's documentation won't work because, for whatever reason, the keyboard is called AFTER the textViewDidBeginEditing is called. I handled this by calling a central method that checks if the keyboard is displayed AND if a textView or textField is being edited. This way, the process is only fired when BOTH conditions exists.

Another point with textViews is that their height may be such that the keyboard clips the bottom of the textView and would not adjust if the Top-Left point of the was in view. So, the code I wrote actually takes the screen-referenced Bottom-Left point of any textView or textField and sees if it falls in the screen-referenced coordinates of the presented keyboard implying that the keyboard covers some portion of it.

let aRect : CGRect = scrollView.convertRect(activeFieldRect!, toView: nil)

    if (CGRectContainsPoint(keyboardRect!, CGPointMake(aRect.origin.x, aRect.maxY))) {

        // scroll textView/textField into view

    }

If you're using a navigation controller, the subclass also sets the scroll view automatic adjustment for insets to false.

self.automaticallyAdjustsScrollViewInsets = false

It walks through each textView and textField to set delegates for handling

    for view in self.view.subviews {

        if view is UITextView {

            let tv = view as! UITextView

            tv.delegate = self

        } else if view is UITextField {

            let tf = view as! UITextField

            tf.delegate = self

        }

    }

Simply set your base class to the subclass created here for results.

import UIKit



class ScrollingFormViewController: UIViewController, UITextViewDelegate, UITextFieldDelegate {



var activeFieldRect: CGRect?

var keyboardRect: CGRect?

var scrollView: UIScrollView!



override func viewDidLoad() {



    self.automaticallyAdjustsScrollViewInsets = false



    super.viewDidLoad()



    // Do any additional setup after loading the view.

    self.registerForKeyboardNotifications()

    for view in self.view.subviews {

        if view is UITextView {

            let tv = view as! UITextView

            tv.delegate = self

        } else if view is UITextField {

            let tf = view as! UITextField

            tf.delegate = self

        }

    }

    scrollView = UIScrollView(frame: self.view.frame)

    scrollView.scrollEnabled = false

    scrollView.showsVerticalScrollIndicator = false

    scrollView.showsHorizontalScrollIndicator = false

    scrollView.addSubview(self.view)

    self.view = scrollView

}



override func viewDidLayoutSubviews() {

    scrollView.sizeToFit()

    scrollView.contentSize = scrollView.frame.size

    super.viewDidLayoutSubviews()

}



deinit {

    self.deregisterFromKeyboardNotifications()

}



override func didReceiveMemoryWarning() {

    super.didReceiveMemoryWarning()

    // Dispose of any resources that can be recreated.

}





func registerForKeyboardNotifications()

{

    //Adding notifies on keyboard appearing

    NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(ScrollingFormViewController.keyboardWasShown), name: UIKeyboardWillShowNotification, object: nil)

    NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(ScrollingFormViewController.keyboardWillBeHidden), name: UIKeyboardWillHideNotification, object: nil)

}





func deregisterFromKeyboardNotifications()

{

    //Removing notifies on keyboard appearing

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

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

}



func keyboardWasShown(notification: NSNotification)

{

    let info : NSDictionary = notification.userInfo!

    keyboardRect = (info[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue()

    adjustForKeyboard()

}





func keyboardWillBeHidden(notification: NSNotification)

{

    keyboardRect = nil

    adjustForKeyboard()

}



func adjustForKeyboard() {

    if keyboardRect != nil && activeFieldRect != nil {

        let aRect : CGRect = scrollView.convertRect(activeFieldRect!, toView: nil)

        if (CGRectContainsPoint(keyboardRect!, CGPointMake(aRect.origin.x, aRect.maxY)))

        {

            scrollView.scrollEnabled = true

            let contentInsets : UIEdgeInsets = UIEdgeInsetsMake(0.0, 0.0, keyboardRect!.size.height, 0.0)

            scrollView.contentInset = contentInsets

            scrollView.scrollIndicatorInsets = contentInsets

            scrollView.scrollRectToVisible(activeFieldRect!, animated: true)

        }

    } else {

        let contentInsets : UIEdgeInsets = UIEdgeInsetsZero

        scrollView.contentInset = contentInsets

        scrollView.scrollIndicatorInsets = contentInsets

        scrollView.scrollEnabled = false

    }

}



func textViewDidBeginEditing(textView: UITextView) {

    activeFieldRect = textView.frame

    adjustForKeyboard()

}



func textViewDidEndEditing(textView: UITextView) {

    activeFieldRect = nil

    adjustForKeyboard()

}



func textFieldDidBeginEditing(textField: UITextField)

{

    activeFieldRect = textField.frame

    adjustForKeyboard()

}



func textFieldDidEndEditing(textField: UITextField)

{

    activeFieldRect = nil

    adjustForKeyboard()

}



}

In the example below, I am only moving the view up when I start editing the txtLastName or txtCity. I created the variable keyboardActive because the view can move up 2x if I click in txtLastName and after that txtCity.

Take a look and see if it works for you.

class ViewController: UIViewController, UITextFieldDelegate {



   @IBOutlet weak var txtFirstName: UITextField!

   @IBOutlet weak var txtLastName: UITextField!

   @IBOutlet weak var txtCity: UITextField!



   var keyboardActive = false



   override func viewDidLoad() {

       super.viewDidLoad()

       self.txtFirstName.delegate = self

       self.txtLastName.delegate = self

       self.txtCity.delegate = self

   }



   func textFieldDidBeginEditing(textField: UITextField) {

      if textField != self.txtFirstName && keyboardActive == false {

          self.view.frame.origin.y -= 165

          self.keyboardActive = true

      }

   }



   func textFieldShouldEndEditing(textField: UITextField) -> Bool {

      if textField != self.txtFirstName && keyboardActive == true {

          self.view.frame.origin.y += 165

          self.keyboardActive = false

      }

      return true

   }



   func textFieldShouldReturn(textField: UITextField) -> Bool {

      self.view.endEditing(true)

      return false

   }



}

Awesome answers are already given but this is a different way to deal with this situation (using Swift 3x):

First of all call the following method in viewWillAppear()

func registerForKeyboardNotifications() {



NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWasShown), name: NSNotification.Name.UIKeyboardDidShow, object: nil)

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



}

Now take one IBOutlet of UIView's top constraints of your UIViewcontroller like this: (here the UIView is the subview of UIScrollView that means you should have a UIScrollView for all your subViews)

@IBOutlet weak var loginViewTopConstraint: NSLayoutConstraint!

And an another variable like following and add a delegate i.e. UITextFieldDelegate:

var activeTextField = UITextField() //This is to keep the reference of UITextField currently active

After that here is the magical part just paste this below snippet:

func keyboardWasShown(_ notification: Notification) {



let keyboardInfo  = notification.userInfo as NSDictionary?



//print(keyboardInfo!)



let keyboardFrameEnd: NSValue? = (keyboardInfo?.value(forKey: UIKeyboardFrameEndUserInfoKey) as? NSValue)



let keyboardFrameEndRect: CGRect? = keyboardFrameEnd?.cgRectValue





if activeTextField.frame.origin.y + activeTextField.frame.size.height + 10 > (keyboardFrameEndRect?.origin.y)! {



    UIView.animate(withDuration: 0.3, delay: 0, options: .transitionFlipFromTop, animations: {() -> Void in



        //code with animation



        //Print some stuff to know what is actually happening

        //print(self.activeTextField.frame.origin.y)

        //print(self.activeTextField.frame.size.height)

        //print(self.activeTextField.frame.size.height)



        self.loginViewTopConstraint.constant = -(self.activeTextField.frame.origin.y + self.activeTextField.frame.size.height - (keyboardFrameEndRect?.origin.y)!) - 30.0



        self.view.layoutIfNeeded()



    }, completion: {(_ finished: Bool) -> Void in

        //code for completion



    })

}

}



func keyboardWillBeHidden(_ notification: Notification) {



UIView.animate(withDuration: 0.3, animations: {() -> Void in



    self.loginViewTopConstraint.constant = self.view.frame.origin.y

    self.view.layoutIfNeeded()



})

}



//MARK: textfield delegates

func textFieldShouldBeginEditing(_ textField: UITextField) -> Bool {

    activeTextField = textField

    return true

}



func textFieldShouldReturn(_ textField: UITextField) -> Bool {



           switch textField {

    case YOUR_TEXTFIELD_ONE:

        YOUR_TEXTFIELD_TWO.becomeFirstResponder()

        break

    case YOUR_TEXTFIELD_TWO:

        YOUR_TEXTFIELD_THREE.becomeFirstResponder()

        break

    default:

        textField.resignFirstResponder()

        break

    }

    return true

}

Now the last snippet:

//Remove Keyboard Observers

override func viewWillDisappear(_ animated: Bool) {



NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIKeyboardDidShow, object: nil)



NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIKeyboardWillHide, object: nil)

}

Don't forget to assign delegates to all your UITextFields in UIStoryboard

Good luck!

Swift 3 syntax:

func textFieldDidBeginEditing(_ textField: UITextField) {

    // add if for some desired textfields

        animateViewMoving(up: true, moveValue: 100)

}



func textFieldDidEndEditing(_ textField: UITextField) {

    // add if for some desired textfields

        animateViewMoving(up: false, moveValue: 100)

}



func animateViewMoving (up:Bool, moveValue :CGFloat){

     textFieldDidEndEditing(_ textField: UITextField) {



    let movementDuration:TimeInterval = 0.5



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

}

this is a nice method to get what you want
you can add "if" conditions for certain textfields
but this type works for all... Hope it can be useful for everyone

"I forgot to mention that I am new to Swift :( What would be the correct syntax to check this? (how do I get the field name in this function?) "

Ok . First confirm to the UITextFieldDelegate protocol

class YourClass:UITextFieldDelegate

Then implement the function

func textFieldDidBeginEditing(textField: UITextField!) {



    if textField == txtOne

    {

        println("TextOne")

    }

    if textField == txtTwo

    {

        println("TextTwo")

    }

}

You should note that the proper approach is to use a scrollview and place the view that should be shifted up/down inside the scroll view and handle keyboard events accordingly

This code moves up the text field you are editing so that you can view it in Swift 3 for this answer you also have to make your view a UITextFieldDelegate:

var moveValue: CGFloat!

var moved: Bool = false

var activeTextField = UITextField()



func textFieldDidBeginEditing(_ textField: UITextField) {

    self.activeTextField = textField

}

func textFieldDidEndEditing(_ textField: UITextField) {

    if moved == true{

    self.animateViewMoving(up: false, moveValue: moveValue )

        moved = false

    }

}

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

}

And then in viewDidLoad:

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

Which calls (outside viewDidLoad):

func keyboardWillShow(notification: Notification) {

    if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {

        let keyboardHeight = keyboardSize.height

        if (view.frame.size.height-self.activeTextField.frame.origin.y) - self.activeTextField.frame.size.height < keyboardHeight{

            moveValue = keyboardHeight - ((view.frame.size.height-self.activeTextField.frame.origin.y) - self.activeTextField.frame.size.height)

            self.animateViewMoving(up: true, moveValue: moveValue )

            moved = true

        }

    }

}

Swift 3

@IBOutlet var scrollView: UIScrollView!

@IBOutlet var edtEmail: UITextField!

@IBOutlet var bottomTextfieldConstrain: NSLayoutConstraint! // <- this guy is the constrain that connect the bottom of textField to lower object or bottom of page!



 @IBAction func edtEmailEditingDidBegin(_ sender: Any) { 

        self.bottomTextfieldConstrain.constant = 200

        let point = CGPoint(x: 0, y: 200)

        scrollView.contentOffset = point

    }



@IBAction func edtEmailEditingDidEnd(_ sender: Any) { 

    self.bottomTextfieldConstrain.constant = 50

}

The accepted anwser is nearly perfect. But I need to use UIKeyboardFrameEndUserInfoKey instead of UIKeyboardFrameBeginUserInfoKey, because the latter return keyborad height 0. And change the hittest point to the bottom not origin.

    var aRect : CGRect = self.view.frame

    aRect.size.height -= keyboardSize!.height

    if let activeField = self.activeField {

        var point = activeField.frame.origin

        point.y += activeField.frame.size.height

        if (!aRect.contains(point)){

            self.scrollView.scrollRectToVisible(activeField.frame, animated: true)

        }

    }

First of all declare a variable to identify your active UITextField.

Step 1:-

Like as var activeTextField: UITextField?

Step 2:-
After this add these two lines in viewDidLoad.

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)

Step 3:-

Now define these two methods in your controller class.

func keyboardWillShow(_ notification: NSNotification) {



    self.scrollView.isScrollEnabled = true

    var info = notification.userInfo!

    let keyboardSize = (info[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue.size

    let contentInsets : UIEdgeInsets = UIEdgeInsetsMake(0.0, 0.0, keyboardSize!.height, 0.0)



    self.scrollView.contentInset = contentInsets

    self.scrollView.scrollIndicatorInsets = contentInsets



    var aRect : CGRect = self.view.frame

    aRect.size.height -= keyboardSize!.height

    if let activeField = self.activeField {

        if (!aRect.contains(activeField.frame.origin)){

            self.scrollView.scrollRectToVisible(activeField.frame, animated: true)

        }

    }

}





func keyboardWillHide(_ notification: NSNotification) {



    let contentInsets : UIEdgeInsets = UIEdgeInsetsMake(0.0, 0.0, 0.0, 0.0)

    self.scrollView.contentInset = contentInsets

    self.scrollView.scrollIndicatorInsets = contentInsets

    self.view.endEditing(true)

    self.scrollView.isScrollEnabled = true

}





func textFieldDidBeginEditing(_ textField: UITextField){



    activeField = textField

}



func textFieldDidEndEditing(_ textField: UITextField){



    activeField = nil

}

Swift 4 Updated my solution

with constraint animation on keyboard show/hide,
enjoy.

import Foundation

import UIKit



class PhoneController: UIViewController, UITextFieldDelegate{



    var phoneLayoutYConstraint: NSLayoutConstraint?



    override func viewDidLoad() {



        super.viewDidLoad()



        view.backgroundColor = .white



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

        NotificationCenter.default.addObserver(self, selector: #selector(handleKeyBoardNotification(_:)), name: NSNotification.Name.UIKeyboardWillHide, object: nil)

        phoneField.delegate = self



        view.addSubview(phoneField)



        NSLayoutConstraint.activate([phoneField.heightAnchor.constraint(equalToConstant: 50),

                                     phoneField.centerXAnchor.constraint(equalTo: view.centerXAnchor),

                                     phoneField.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 20),

                                     phoneField.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -20)])



        phoneLayoutYConstraint = NSLayoutConstraint(item: phoneField, attribute: .bottom, relatedBy: .equal, toItem: view, attribute: .bottom, multiplier: 1, constant: 0)

        phoneLayoutYConstraint?.isActive = true



    }



    let phoneField: UITextField = {

        let text = UITextField()

        text.translatesAutoresizingMaskIntoConstraints = false

        text.keyboardType = .numberPad

        text.font = UIFont.systemFont(ofSize: 30)

        text.layer.cornerRadius = 5.0

        text.layer.masksToBounds = true

        text.layer.borderColor = UIColor.darkGray.cgColor

        text.layer.borderWidth = 2.0



        return text

    }()





    override func viewDidDisappear(_ animated: Bool) {

        super.viewWillDisappear(animated)

        NotificationCenter.default.removeObserver(self)

    }



    func textFieldDidBeginEditing(_ textField: UITextField) {



    }





    func textFieldDidEndEditing(_ textField: UITextField) {



    }



    func textFieldShouldReturn(_ textField: UITextField) -> Bool {

        textField.resignFirstResponder()

        return true

    }





   @objc func handleKeyBoardNotification(_ notification: NSNotification) {



        if let info = notification.userInfo {



            let keyboardSize = (info[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue.size

            let isKeyBoardShowing = notification.name == NSNotification.Name.UIKeyboardWillShow



            var aRect : CGRect = self.phoneField.frame

            aRect.size.height -= keyboardSize!.height





            phoneLayoutYConstraint?.constant = isKeyBoardShowing ? -keyboardSize!.height : 0



            UIView.animate(withDuration: 0, delay: 0, options: .curveEaseOut, animations: {

                self.view.layoutIfNeeded()

            }, completion: { (boo) in



            })



        }

    }



}

Swift 4

You Can Easily Move Up And Down UITextField With Keyboard With Animation

import UIKit



class ViewController: UIViewController {



    @IBOutlet var textField: UITextField!



    override func viewDidLoad() {

        super.viewDidLoad()

        NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillChange), name: .UIKeyboardWillChangeFrame, object: nil)

    }



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

        textField.resignFirstResponder()

    }



    @objc func keyboardWillChange(notification: NSNotification) {



        let duration = notification.userInfo![UIKeyboardAnimationDurationUserInfoKey] as! Double

        let curve = notification.userInfo![UIKeyboardAnimationCurveUserInfoKey] as! UInt

        let curFrame = (notification.userInfo![UIKeyboardFrameBeginUserInfoKey] as! NSValue).cgRectValue

        let targetFrame = (notification.userInfo![UIKeyboardFrameEndUserInfoKey] as! NSValue).cgRectValue

        let deltaY = targetFrame.origin.y - curFrame.origin.y



        UIView.animateKeyframes(withDuration: duration, delay: 0.0, options: UIViewKeyframeAnimationOptions(rawValue: curve), animations: {

            self.textField.frame.origin.y+=deltaY



        },completion: nil)

    }

Swift 4.2

My solution will (vertically) center the view on a UITextField if its position is under the keyboard.

Step 1: Create new swift file and copy-paste UIViewWithKeyboard class.

Step 2: In Interface Builder set it as a Custom Class for your top most UIView.

import UIKit



class UIViewWithKeyboard: UIView {

    @IBInspectable var offsetMultiplier: CGFloat = 0.75

    private var keyboardHeight = 0 as CGFloat

    private weak var activeTextField: UITextField?

    override func awakeFromNib() {

        super.awakeFromNib()

        NotificationCenter.default.addObserver(self, selector: #selector(UIViewWithKeyboard.textDidBeginEditing),

                                               name: UITextField.textDidBeginEditingNotification, object: nil)

        NotificationCenter.default.addObserver(self, selector: #selector(UIViewWithKeyboard.keyboardWillShow),

                                               name: UIResponder.keyboardWillShowNotification, object: nil)

        NotificationCenter.default.addObserver(self, selector: #selector(UIViewWithKeyboard.keyboardWillHide),

                                               name: UIResponder.keyboardWillHideNotification, object: nil)

    }



    @objc func textDidBeginEditing(_ notification: NSNotification) {

        self.activeTextField = notification.object as? UITextField

    }



    @objc func keyboardWillShow(_ notification: Notification) {

        if let frameValue = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue {

            keyboardHeight = frameValue.cgRectValue.size.height

            if let textField = self.activeTextField {

                let offset = textField.frame.maxY < frame.maxY - keyboardHeight ? 0

                           : textField.frame.maxY - (frame.maxY - keyboardHeight) * offsetMultiplier

                self.setView(offset: offset)

            }

        }

    }



    @objc func keyboardWillHide(_ notification: NSNotification) {

        self.setView(offset: 0)

    }



    func setView(offset: CGFloat) {

        UIView.animate(withDuration: 0.25) {

            self.bounds.origin.y = offset

        }

    }

}

for swift 4.2.

This will apply to any form. No need of scrollview.

//make a var of uitextfield

var clickedTextField = UITextField()

//in your viewdid load

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

//know the clicked text field. probably you are having textfields on the entire screen.

 func textFieldDidBeginEditing(_ textField: UITextField) {





            clickedTextField = textField





}

//check if the keyboard is covering textfield or not.

 @objc func keyboardWillShow(sender: NSNotification,_ textField : UITextField) {

    if let keyboardSize = (sender.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {



        if clickedTextField.frame.origin.y > keyboardSize.origin.y {

            self.view.frame.origin.y = keyboardSize.origin.y - clickedTextField.center.y - 20

        }

    }





}



@objc func keyboardWillHide(sender: NSNotification) {

    self.view.frame.origin.y = 0

}

//return to close keyboard

   func textFieldShouldReturn(_ textField: UITextField) -> Bool {   //delegate method

    textField.resignFirstResponder()

    return true

}

UPDATE :
NSNotification.Name.UIKeyboardWillShow & NSNotification.Name.UIKeyboardWillHide are renamed to UIResponder.keyboardWillShowNotification & UIResponder.keyboardWillHideNotification respectively.

The problem like this in ReactNative android and IOS apps is solved by following the below steps.

install the package like this.

 $ npm install --save react-native-keyboard-spacer

Now import keyboard spacer into your js or jsx files in React Native project like this.

 import React, { Component } from 'react';

 import KeyboardSpacer from 'react-native-keyboard-spacer';

 import { View, Text, TextInput } from 'react-native';



 export default class Sample extends Component{

    render(){

       return(

           <View style={{flex: 1}}>

              <TextInput 

                  placeholderTextColor="£000000"

                  underlineColorAndroid="transparent"

                  keyboardType="default"

                  maxLength={30}

                  placeholder={'Enter your text!'} />



              <TextInput placeholder={"another text field"} />



              <TextInput placeholder={"another text field"} />



              {/* now place the below component after your input fields form block or view */}



             <KeyboardSpacer/>

          </View>

       );

    }

 } 

Then the keyboard issue of hiding the text fields while writing will be solved.

   Note: It will work both IOS and Android React Native apps.



   Hope It is helpful to others.