react-native-keyboard-controller 1.15.2 → 1.16.1

package/ios/extensions/UIResponder.swift

@@ -44,6 +44,20 @@ public extension Optional where Wrapped == UIResponder {
       return (self as? UIView)?.superview?.reactTag ?? -1
     #endif
   }
+
+  var nativeID: String? {
+    guard let superview = (self as? UIView)?.superview else { return nil }
+
+    #if KEYBOARD_CONTROLLER_NEW_ARCH_ENABLED
+      if superview.responds(to: Selector(("nativeId"))) == true {
+        return (superview as NSObject).value(forKey: "nativeId") as? String
+      }
+
+      return nil
+    #else
+      return superview.nativeID
+    #endif
+  }
 }
 
 public extension Optional where Wrapped: UIResponder {

package/ios/interactive/InvisibleInputAccessoryView.swift

@@ -0,0 +1,59 @@
+//
+//  InvisibleInputAccessoryView.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 01/11/2024.
+//
+
+import Foundation
+import UIKit
+
+public class InvisibleInputAccessoryView: UIView {
+  var isShown = true
+
+  override init(frame: CGRect) {
+    super.init(frame: frame)
+    setupView()
+  }
+
+  public convenience init(height: CGFloat) {
+    self.init(frame: CGRect(x: 0, y: 0, width: 0, height: height))
+  }
+
+  required init?(coder aDecoder: NSCoder) {
+    super.init(coder: aDecoder)
+    setupView()
+  }
+
+  override public func point(inside _: CGPoint, with _: UIEvent?) -> Bool {
+    // Return false to allow touch events to pass through
+    return false
+  }
+
+  public func updateHeight(to newHeight: CGFloat) {
+    frame = CGRect(x: 0, y: 0, width: 0, height: newHeight)
+
+    // Invalidate intrinsic content size to trigger a layout update
+    invalidateIntrinsicContentSize()
+    layoutIfNeeded()
+  }
+
+  public func hide() {
+    guard isShown else { return }
+    isShown = false
+    updateHeight(to: 0.0)
+    superview?.layoutIfNeeded()
+  }
+
+  override public var intrinsicContentSize: CGSize {
+    return CGSize(width: UIView.noIntrinsicMetric, height: frame.height)
+  }
+
+  private func setupView() {
+    isUserInteractionEnabled = false
+    // for debug purposes
+    // backgroundColor = UIColor.red.withAlphaComponent(0.2)
+    backgroundColor = .clear
+    autoresizingMask = .flexibleHeight
+  }
+}

package/ios/interactive/KeyboardAreaExtender.swift

@@ -0,0 +1,74 @@
+//
+//  KeyboardAreaExtender.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 02/11/2024.
+//
+
+class KeyboardAreaExtender: NSObject {
+  private var currentInputAccessoryView: InvisibleInputAccessoryView?
+
+  @objc public static let shared = KeyboardAreaExtender()
+
+  override private init() {
+    super.init()
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(keyboardDidAppear),
+      name: UIResponder.keyboardDidShowNotification,
+      object: nil
+    )
+  }
+
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+
+  public var offset: CGFloat {
+    return currentInputAccessoryView?.frame.height ?? 0
+  }
+
+  public func hide() {
+    if isVisible {
+      NotificationCenter.default.post(
+        name: .shouldIgnoreKeyboardEvents, object: nil, userInfo: ["ignore": true]
+      )
+      currentInputAccessoryView?.hide()
+    }
+  }
+
+  public func remove() {
+    currentInputAccessoryView = nil
+  }
+
+  public func updateHeight(to newHeight: CGFloat, for nativeID: String) {
+    if UIResponder.current.nativeID == nativeID {
+      currentInputAccessoryView?.updateHeight(to: newHeight)
+    }
+  }
+
+  private var isVisible: Bool {
+    return currentInputAccessoryView?.isShown ?? false
+  }
+
+  @objc private func keyboardDidAppear(_: Notification) {
+    let responder = UIResponder.current
+    if let activeTextInput = responder as? TextInput,
+       let offset = KeyboardOffsetProvider.shared.getOffset(
+         forTextInputNativeID: responder.nativeID),
+       responder?.inputAccessoryView == nil
+    {
+      currentInputAccessoryView = InvisibleInputAccessoryView(height: CGFloat(truncating: offset))
+
+      // we need to send this event before we actually attach the IAV
+      // since on some OS versions (iOS 15 for example), `reloadInputViews`
+      // will trigger `keyboardDidAppear` listener immediately
+      NotificationCenter.default.post(
+        name: .shouldIgnoreKeyboardEvents, object: nil, userInfo: ["ignore": true]
+      )
+
+      activeTextInput.inputAccessoryView = currentInputAccessoryView
+      activeTextInput.reloadInputViews()
+    }
+  }
+}

package/ios/interactive/KeyboardOffsetProvider.swift

@@ -0,0 +1,39 @@
+//
+//  KeyboardOffsetProvider.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 01/11/2024.
+//
+
+import Foundation
+
+@objc(KeyboardOffsetProvider)
+public class KeyboardOffsetProvider: NSObject {
+  @objc public static let shared = KeyboardOffsetProvider()
+
+  override private init() {}
+
+  private var offsetMap: [String: (offset: NSNumber, tag: NSNumber)] = [:]
+
+  @objc public func setOffset(forTextInputNativeID nativeID: String, offset: NSNumber, withTag tag: NSNumber) {
+    KeyboardAreaExtender.shared.updateHeight(to: CGFloat(offset), for: nativeID)
+    offsetMap[nativeID] = (offset: offset, tag: tag)
+  }
+
+  @objc public func getOffset(forTextInputNativeID nativeID: String?) -> NSNumber? {
+    guard let unwrappedNativeID = nativeID, let pair = offsetMap[unwrappedNativeID] else { return nil }
+    return pair.offset
+  }
+
+  @objc public func hasOffset(forTextInputNativeID nativeID: String?) -> Bool {
+    guard let unwrappedNativeID = nativeID else { return false }
+    return offsetMap[unwrappedNativeID] != nil
+  }
+
+  @objc public func removeOffset(forTextInputNativeID nativeID: String, withTag tag: NSNumber) {
+    // Ensure the tag matches before removing the entry
+    if let currentPair = offsetMap[nativeID], currentPair.tag == tag {
+      offsetMap.removeValue(forKey: nativeID)
+    }
+  }
+}

package/ios/observers/FocusedInputObserver.swift

@@ -37,7 +37,7 @@ public class FocusedInputObserver: NSObject {
   // input tracking
   private var currentInput: UIView?
   private var currentResponder: UIView?
-  private var hasObservers = false
+  private var observation: NSKeyValueObservation?
   private var lastEventDispatched: [AnyHashable: Any] = noFocusedInputEvent
 
   @objc public init(
@@ -76,7 +76,7 @@ public class FocusedInputObserver: NSObject {
 
     NotificationCenter.default.addObserver(
       self,
-      selector: #selector(keyboardWillShow),
+      selector: #selector(didReceiveFocus),
       name: UIResponder.keyboardWillShowNotification,
       object: nil
     )
@@ -86,6 +86,30 @@ public class FocusedInputObserver: NSObject {
       name: UIResponder.keyboardWillHideNotification,
       object: nil
     )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(didReceiveFocus),
+      name: UITextField.textDidBeginEditingNotification,
+      object: nil
+    )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(didReceiveFocus),
+      name: UITextView.textDidBeginEditingNotification,
+      object: nil
+    )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(didReceiveBlur),
+      name: UITextField.textDidEndEditingNotification,
+      object: nil
+    )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(didReceiveBlur),
+      name: UITextView.textDidEndEditingNotification,
+      object: nil
+    )
   }
 
   @objc public func unmount() {
@@ -94,7 +118,41 @@ public class FocusedInputObserver: NSObject {
     NotificationCenter.default.removeObserver(self)
   }
 
-  @objc func keyboardWillShow(_: Notification) {
+  @objc func keyboardWillHide(_: Notification) {
+    onBlur()
+  }
+
+  @objc func didReceiveFocus(_: Notification) {
+    if UIResponder.current == currentResponder {
+      // focus was already handled by keyboard event
+      return
+    }
+
+    onFocus()
+  }
+
+  /**
+   * We handle blur events in `keyboardWillHide` handler
+   * And this additional handler is needed only to have
+   * a consistent state when keyboard is not shown
+   */
+  @objc func didReceiveBlur(_: Notification) {
+    if currentResponder == nil {
+      // blur was already handled by keyboard event
+      return
+    }
+    // blur gets triggered on endEditing, so we check if no upcoming
+    // didReceiveFocus events are coming to exclude `noFocusedInput`
+    // event when user switches between inputs
+    DispatchQueue.main.async {
+      // check that it wasn't a switch between inputs
+      if self.currentResponder == nil {
+        self.onBlur()
+      }
+    }
+  }
+
+  func onFocus() {
     guard let responder = UIResponder.current as? UIView else { return }
     removeObservers(newResponder: responder)
     currentResponder = responder
@@ -106,7 +164,7 @@ public class FocusedInputObserver: NSObject {
     FocusedInputHolder.shared.set(currentResponder as? TextInput)
 
     let allInputFields = ViewHierarchyNavigator.getAllInputFields()
-    let currentIndex = allInputFields.firstIndex(where: { $0 as? UIView == currentResponder }) ?? -1
+    let currentIndex = allInputFields.firstIndex(where: { $0 == currentResponder }) ?? -1
 
     onFocusDidSet([
       "current": currentIndex,
@@ -114,7 +172,11 @@ public class FocusedInputObserver: NSObject {
     ])
   }
 
-  @objc func keyboardWillHide(_: Notification) {
+  func onBlur() {
+    // when we switch to next input, but `showSoftInput={false}`
+    if UIResponder.current is TextInput {
+      return
+    }
     removeObservers(newResponder: nil)
     currentInput = nil
     currentResponder = nil
@@ -162,25 +224,27 @@ public class FocusedInputObserver: NSObject {
   }
 
   private func setupObservers() {
-    if hasObservers {
+    if observation != nil {
       return
     }
 
     if currentInput != nil {
-      hasObservers = true
-      currentInput?.addObserver(self, forKeyPath: "center", options: .new, context: nil)
+      observation = currentInput?.observe(\.center, options: .new) { [weak self] view, change in
+        guard let self = self else { return }
+        self.onLayoutChange(view: view, change: change)
+      }
 
       substituteDelegate(currentResponder)
     }
   }
 
   private func removeObservers(newResponder: UIResponder?) {
-    if newResponder == currentResponder || !hasObservers {
+    if newResponder == currentResponder || observation == nil {
       return
     }
 
-    hasObservers = false
-    currentInput?.removeObserver(self, forKeyPath: "center", context: nil)
+    observation?.invalidate()
+    observation = nil
 
     substituteDelegateBack(currentResponder)
   }
@@ -188,7 +252,7 @@ public class FocusedInputObserver: NSObject {
   private func substituteDelegate(_ input: UIResponder?) {
     if let textField = input as? UITextField {
       if !(textField.delegate is KCTextInputCompositeDelegate) {
-        delegate.setTextFieldDelegate(delegate: textField.delegate)
+        delegate.setTextFieldDelegate(delegate: textField.delegate, textField: textField)
         textField.delegate = delegate
       }
     } else if let textView = input as? UITextView {
@@ -211,19 +275,11 @@ public class FocusedInputObserver: NSObject {
     }
   }
 
-  // swiftlint:disable:next block_based_kvo
-  @objc override public func observeValue(
-    forKeyPath keyPath: String?,
-    of object: Any?,
-    change _: [NSKeyValueChangeKey: Any]?,
-    context _: UnsafeMutableRawPointer?
-  ) {
-    if keyPath == "center", object as? NSObject == currentInput {
-      // we need to read layout in next frame, otherwise we'll get old
-      // layout values
-      DispatchQueue.main.async {
-        self.syncUpLayout()
-      }
+  private func onLayoutChange(view _: UIView, change _: NSKeyValueObservedChange<CGPoint>) {
+    // we need to read layout in next frame, otherwise we'll get old
+    // layout values
+    DispatchQueue.main.async {
+      self.syncUpLayout()
     }
   }
 

package/ios/observers/KeyboardEventsIgnorer.swift

@@ -0,0 +1,39 @@
+//
+//  KeyboardEventsIgnorer.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 24/11/2024.
+//
+
+import Foundation
+
+@objc(KeyboardEventsIgnorer)
+public class KeyboardEventsIgnorer: NSObject {
+  @objc public static let shared = KeyboardEventsIgnorer()
+
+  var shouldIgnoreKeyboardEvents = false
+
+  public var shouldIgnore: Bool {
+    return shouldIgnoreKeyboardEvents
+  }
+
+  override init() {
+    super.init()
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(handleIgnoreKeyboardEventsNotification),
+      name: .shouldIgnoreKeyboardEvents,
+      object: nil
+    )
+  }
+
+  @objc private func handleIgnoreKeyboardEventsNotification(_ notification: Notification) {
+    if let userInfo = notification.userInfo, let value = userInfo["ignore"] as? Bool {
+      shouldIgnoreKeyboardEvents = value
+    }
+  }
+
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+}

package/ios/observers/KeyboardMovementObserver.swift

@@ -33,10 +33,15 @@ public class KeyboardMovementObserver: NSObject {
   private var _windowsCount: Int = 0
   private var prevKeyboardPosition = 0.0
   private var displayLink: CADisplayLink?
-  private var hasKVObserver = false
+  private var interactiveKeyboardObserver: NSKeyValueObservation?
   private var isMounted = false
   // state variables
-  private var keyboardHeight: CGFloat = 0.0
+  private var _keyboardHeight: CGFloat = 0.0
+  private var keyboardHeight: CGFloat {
+    get { _keyboardHeight - KeyboardAreaExtender.shared.offset }
+    set { _keyboardHeight = newValue }
+  }
+
   private var duration = 0
   private var tag: NSNumber = -1
   private var animation: KeyboardAnimation?
@@ -88,72 +93,57 @@ public class KeyboardMovementObserver: NSObject {
   }
 
   private func setupKVObserver() {
-    if hasKVObserver {
-      return
-    }
+    guard interactiveKeyboardObserver == nil, let view = keyboardView else { return }
 
-    if keyboardView != nil {
-      hasKVObserver = true
-      keyboardView?.addObserver(self, forKeyPath: "center", options: .new, context: nil)
+    interactiveKeyboardObserver = view.observe(\.center, options: .new) { [weak self] _, change in
+      guard let self = self, let changeValue = change.newValue else { return }
+
+      self.keyboardDidMoveInteractively(changeValue: changeValue)
     }
   }
 
   private func removeKVObserver() {
-    if !hasKVObserver {
+    interactiveKeyboardObserver?.invalidate()
+    interactiveKeyboardObserver = nil
+  }
+
+  private func keyboardDidMoveInteractively(changeValue: CGPoint) {
+    // if we are currently animating keyboard -> we need to ignore values from KVO
+    if displayLink != nil {
+      return
+    }
+    // if keyboard height is not equal to its bounds - we can ignore
+    // values, since they'll be invalid and will cause UI jumps
+    if floor(keyboardView?.bounds.size.height ?? 0) != floor(_keyboardHeight) {
       return
     }
 
-    hasKVObserver = false
-    _keyboardView?.removeObserver(self, forKeyPath: "center", context: nil)
-  }
+    let keyboardFrameY = changeValue.y
+    let keyboardWindowH = keyboardView?.window?.bounds.size.height ?? 0
+    let keyboardPosition = keyboardWindowH - keyboardFrameY
 
-  // swiftlint:disable:next block_based_kvo
-  @objc override public func observeValue(
-    forKeyPath keyPath: String?,
-    of object: Any?,
-    change: [NSKeyValueChangeKey: Any]?,
-    context _: UnsafeMutableRawPointer?
-  ) {
-    if keyPath == "center", object as? NSObject == _keyboardView {
-      // if we are currently animating keyboard -> we need to ignore values from KVO
-      if displayLink != nil {
-        return
-      }
-      // if keyboard height is not equal to its bounds - we can ignore
-      // values, since they'll be invalid and will cause UI jumps
-      if keyboardView?.bounds.size.height != keyboardHeight {
-        return
-      }
+    let position = CGFloat.interpolate(
+      inputRange: [_keyboardHeight / 2, -_keyboardHeight / 2],
+      outputRange: [_keyboardHeight, 0],
+      currentValue: keyboardPosition
+    ) - KeyboardAreaExtender.shared.offset
 
-      guard let changeValue = change?[.newKey] as? NSValue else {
-        return
-      }
-      let keyboardFrameY = changeValue.cgPointValue.y
-      let keyboardWindowH = keyboardView?.window?.bounds.size.height ?? 0
-      let keyboardPosition = keyboardWindowH - keyboardFrameY
-      let position = CGFloat.interpolate(
-        inputRange: [keyboardHeight / 2, -keyboardHeight / 2],
-        outputRange: [keyboardHeight, 0],
-        currentValue: keyboardPosition
-      )
-
-      if position == 0 {
-        // it will be triggered before `keyboardWillDisappear` and
-        // we don't need to trigger `onInteractive` handler for that
-        // since it will be handled in `keyboardWillDisappear` function
-        return
-      }
+    if position == 0 {
+      // it will be triggered before `keyboardWillDisappear` and
+      // we don't need to trigger `onInteractive` handler for that
+      // since it will be handled in `keyboardWillDisappear` function
+      return
+    }
 
-      prevKeyboardPosition = position
+    prevKeyboardPosition = position
 
-      onEvent(
-        "onKeyboardMoveInteractive",
-        position as NSNumber,
-        position / CGFloat(keyboardHeight) as NSNumber,
-        -1,
-        tag
-      )
-    }
+    onEvent(
+      "onKeyboardMoveInteractive",
+      position as NSNumber,
+      position / CGFloat(keyboardHeight) as NSNumber,
+      -1,
+      tag
+    )
   }
 
   @objc public func unmount() {
@@ -163,6 +153,8 @@ public class KeyboardMovementObserver: NSObject {
   }
 
   @objc func keyboardWillAppear(_ notification: Notification) {
+    guard !KeyboardEventsIgnorer.shared.shouldIgnore else { return }
+
     let (duration, frame) = notification.keyboardMetaData()
     if let keyboardFrame = frame {
       tag = UIResponder.current.reactViewTag
@@ -172,11 +164,11 @@ public class KeyboardMovementObserver: NSObject {
       didShowDeadline = Date.currentTimeStamp + Int64(duration)
 
       onRequestAnimation()
-      onEvent("onKeyboardMoveStart", Float(keyboardHeight) as NSNumber, 1, duration as NSNumber, tag)
-      onNotify("KeyboardController::keyboardWillShow", buildEventParams(keyboardHeight, duration, tag))
+      onEvent("onKeyboardMoveStart", Float(self.keyboardHeight) as NSNumber, 1, duration as NSNumber, tag)
+      onNotify("KeyboardController::keyboardWillShow", buildEventParams(self.keyboardHeight, duration, tag))
 
       setupKeyboardWatcher()
-      initializeAnimation(fromValue: prevKeyboardPosition, toValue: keyboardHeight)
+      initializeAnimation(fromValue: prevKeyboardPosition, toValue: self.keyboardHeight)
     }
   }
 
@@ -202,9 +194,15 @@ public class KeyboardMovementObserver: NSObject {
       let keyboardHeight = keyboardFrame.cgRectValue.size.height
       tag = UIResponder.current.reactViewTag
       self.keyboardHeight = keyboardHeight
+
+      guard !KeyboardEventsIgnorer.shared.shouldIgnore else {
+        KeyboardEventsIgnorer.shared.shouldIgnoreKeyboardEvents = false
+        return
+      }
+
       // if the event is caught in between it's highly likely that it could be a "resize" event
       // so we just read actual keyboard frame value in this case
-      let height = timestamp >= didShowDeadline ? keyboardHeight : position
+      let height = timestamp >= didShowDeadline ? self.keyboardHeight : position - KeyboardAreaExtender.shared.offset
       // always limit progress to the maximum possible value
       let progress = min(height / self.keyboardHeight, 1.0)
 
@@ -267,7 +265,7 @@ public class KeyboardMovementObserver: NSObject {
     }
 
     let (visibleKeyboardHeight, keyboardFrameY) = keyboardView.frameTransitionInWindow
-    var keyboardPosition = visibleKeyboardHeight
+    var keyboardPosition = visibleKeyboardHeight - KeyboardAreaExtender.shared.offset
 
     if keyboardPosition == prevKeyboardPosition || keyboardFrameY == 0 {
       return

package/ios/protocols/TextInput.swift

@@ -11,9 +11,11 @@ import UIKit
 
 public protocol TextInput: UIView {
   // default common methods/properties
+  var inputAccessoryView: UIView? { get set }
   var inputView: UIView? { get set }
   var keyboardType: UIKeyboardType { get }
   var keyboardAppearance: UIKeyboardAppearance { get }
+  // custom methods/properties
   func focus()
 }
 

package/ios/swizzling/UIResponderSwizzle.swift

@@ -0,0 +1,60 @@
+//
+//  UIResponderSwizzle.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 01/11/2024.
+//
+
+import Foundation
+import UIKit
+
+private var originalResignFirstResponder: IMP?
+
+@objc
+extension UIResponder {
+  public static func swizzleResignFirstResponder() {
+    let originalSelector = #selector(resignFirstResponder)
+
+    guard let originalMethod = class_getInstanceMethod(UIResponder.self, originalSelector) else {
+      return
+    }
+
+    originalResignFirstResponder = method_getImplementation(originalMethod)
+
+    let swizzledImplementation: @convention(block) (UIResponder) -> Bool = { (self) in
+      // Check the type of responder
+      if let textField = self as? TextInput {
+        // check inputAccessoryView and call original method immediately if not InvisibleInputAccessoryView
+        if !(textField.inputAccessoryView is InvisibleInputAccessoryView) {
+          return self.callOriginalResignFirstResponder(originalSelector)
+        }
+      } else {
+        // If casting to TextInput fails
+        return self.callOriginalResignFirstResponder(originalSelector)
+      }
+
+      KeyboardAreaExtender.shared.hide()
+
+      // Postpone execution of the original resignFirstResponder
+      DispatchQueue.main.asyncAfter(deadline: .now() + UIUtils.nextFrame) {
+        (self as? TextInput)?.inputAccessoryView = nil
+        KeyboardAreaExtender.shared.remove()
+        _ = self.callOriginalResignFirstResponder(originalSelector)
+      }
+
+      // We need to return a value immediately, even though the actual action is delayed
+      return false
+    }
+
+    let implementation = imp_implementationWithBlock(swizzledImplementation)
+    method_setImplementation(originalMethod, implementation)
+  }
+
+  private func callOriginalResignFirstResponder(_ selector: Selector) -> Bool {
+    guard let originalResignFirstResponder = originalResignFirstResponder else { return false }
+    typealias Function = @convention(c) (AnyObject, Selector) -> Bool
+    let castOriginalResignFirstResponder = unsafeBitCast(originalResignFirstResponder, to: Function.self)
+    let result = castOriginalResignFirstResponder(self, selector)
+    return result
+  }
+}

package/ios/traversal/ViewHierarchyNavigator.swift

@@ -21,7 +21,7 @@ public class ViewHierarchyNavigator: NSObject {
         return
       }
 
-      let input = (FocusedInputHolder.shared.get() as? UIView) ?? (UIResponder.current as? UIView) ?? nil
+      let input = FocusedInputHolder.shared.get() ?? (UIResponder.current as? UIView) ?? nil
       guard let view = input else { return }
 
       let textField = findTextInputInDirection(currentFocus: view, direction: direction)