Introduction

On iOS, you usually do not query the keyboard directly. Instead, you observe keyboard show and hide notifications and keep your own state. This event based approach is reliable, animation friendly, and works well with modern UIKit layouts.

Use Keyboard Notifications as the Source of Truth

UIKit posts notifications when the keyboard frame changes. The most useful ones are keyboard will show, keyboard will hide, and keyboard will change frame. You can subscribe in your view controller and update UI constraints when events arrive.

1import UIKit
2
3final class FormViewController: UIViewController {
4    @IBOutlet private weak var bottomConstraint: NSLayoutConstraint!
5    private(set) var isKeyboardVisible = false
6
7    override func viewDidLoad() {
8        super.viewDidLoad()
9
10        NotificationCenter.default.addObserver(
11            self,
12            selector: #selector(handleKeyboardWillShow(_:)),
13            name: UIResponder.keyboardWillShowNotification,
14            object: nil
15        )
16
17        NotificationCenter.default.addObserver(
18            self,
19            selector: #selector(handleKeyboardWillHide(_:)),
20            name: UIResponder.keyboardWillHideNotification,
21            object: nil
22        )
23    }
24
25    deinit {
26        NotificationCenter.default.removeObserver(self)
27    }
28
29    @objc private func handleKeyboardWillShow(_ note: Notification) {
30        isKeyboardVisible = true
31        updateLayout(from: note)
32    }
33
34    @objc private func handleKeyboardWillHide(_ note: Notification) {
35        isKeyboardVisible = false
36        updateLayout(from: note)
37    }
38
39    private func updateLayout(from note: Notification) {
40        guard let info = note.userInfo,
41              let frame = info[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect,
42              let duration = info[UIResponder.keyboardAnimationDurationUserInfoKey] as? Double,
43              let curveRaw = info[UIResponder.keyboardAnimationCurveUserInfoKey] as? UInt else {
44            return
45        }
46
47        let keyboardHeight = isKeyboardVisible ? frame.height - view.safeAreaInsets.bottom : 0
48        bottomConstraint.constant = keyboardHeight
49
50        let options = UIView.AnimationOptions(rawValue: curveRaw << 16)
51        UIView.animate(withDuration: duration, delay: 0, options: options) {
52            self.view.layoutIfNeeded()
53        }
54    }
55}

This gives you a reliable boolean value and synchronized animation.

Detect Presence for a Specific Screen

Sometimes you only care if the keyboard is present while one screen is active. In that case, register observers in viewWillAppear and remove them in viewWillDisappear.

1override func viewWillAppear(_ animated: Bool) {
2    super.viewWillAppear(animated)
3    NotificationCenter.default.addObserver(
4        self,
5        selector: #selector(handleKeyboardWillShow(_:)),
6        name: UIResponder.keyboardWillShowNotification,
7        object: nil
8    )
9}
10
11override func viewWillDisappear(_ animated: Bool) {
12    super.viewWillDisappear(animated)
13    NotificationCenter.default.removeObserver(self)
14    isKeyboardVisible = false
15}

This avoids stale callbacks hitting inactive controllers.

When To Use Frame Change Notification

Hardware keyboards, split keyboards on iPad, and language changes can alter frame size without a full hide cycle. Subscribe to keyboard will change frame when your layout depends on exact height.

1NotificationCenter.default.addObserver(
2    self,
3    selector: #selector(handleKeyboardWillShow(_:)),
4    name: UIResponder.keyboardWillChangeFrameNotification,
5    object: nil
6)

If you use a scrolling form, consider adjusting content inset instead of fixed constraints so input fields remain visible regardless of keyboard shape.

Testing Keyboard State in Real Devices

Simulator tests are useful, but keyboard behavior can differ with hardware keyboards, split layouts, and third party keyboards. Validate on at least one real iPhone and one iPad configuration. Trigger focus changes between multiple text fields and confirm your isKeyboardVisible state always matches the visual result.

For automated UI tests, you can assert layout changes after tapping a field by checking expected constraint constants or visible element frames. This protects against regressions when refactoring form screens.

Common Pitfalls

• Reading keyboard state from view hierarchy snapshots: this is fragile and can break across iOS versions.
• Forgetting safe area subtraction: bottom inset can be applied twice on newer devices.
• Not removing observers: duplicate callbacks can cause jittery animations.
• Ignoring frame change notification on iPad: layouts may break with floating keyboards.
• Updating UI outside animation timing from notification payload: transitions look abrupt.

Summary

• Keyboard presence in iOS is best tracked through notifications.
• Maintain your own isKeyboardVisible boolean in controller state.
• Use payload values for animation duration and curve to match system motion.
• Handle frame changes for robust iPad and hardware keyboard behavior.
• Scope observer lifecycle to visible screens for clean, predictable callbacks.
• Test with hardware keyboard scenarios to ensure your visibility state and layout updates still behave correctly when the onscreen keyboard is absent.