react-native-keyboard-controller 1.18.2 → 1.18.4

package/android/src/main/java/com/reactnativekeyboardcontroller/modules/statusbar/StatusBarManagerCompatModuleImpl.kt

@@ -9,9 +9,9 @@ import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.UiThreadUtil
-import com.reactnativekeyboardcontroller.extensions.rootView
 import com.reactnativekeyboardcontroller.log.Logger
 import com.reactnativekeyboardcontroller.views.EdgeToEdgeReactViewGroup
+import com.reactnativekeyboardcontroller.views.EdgeToEdgeViewRegistry
 import java.lang.ref.WeakReference
 
 private val TAG = StatusBarManagerCompatModuleImpl::class.qualifiedName
@@ -117,8 +117,7 @@ class StatusBarManagerCompatModuleImpl(
 
   private fun isEnabled(): Boolean = view()?.active ?: false
 
-  private fun view(): EdgeToEdgeReactViewGroup? =
-    mReactContext.rootView?.findViewWithTag<EdgeToEdgeReactViewGroup>(EdgeToEdgeReactViewGroup.VIEW_TAG)
+  private fun view(): EdgeToEdgeReactViewGroup? = EdgeToEdgeViewRegistry.get()
 
   companion object {
     const val NAME = "StatusBarManager"

package/android/src/main/java/com/reactnativekeyboardcontroller/views/EdgeToEdgeReactViewGroup.kt

@@ -19,9 +19,20 @@ import com.reactnativekeyboardcontroller.listeners.KeyboardAnimationCallback
 import com.reactnativekeyboardcontroller.listeners.KeyboardAnimationCallbackConfig
 import com.reactnativekeyboardcontroller.log.Logger
 import com.reactnativekeyboardcontroller.modal.ModalAttachedWatcher
+import java.lang.ref.WeakReference
 
 private val TAG = EdgeToEdgeReactViewGroup::class.qualifiedName
 
+object EdgeToEdgeViewRegistry {
+  private var lastCreatedView: WeakReference<EdgeToEdgeReactViewGroup>? = null
+
+  fun register(view: EdgeToEdgeReactViewGroup) {
+    lastCreatedView = WeakReference(view)
+  }
+
+  fun get(): EdgeToEdgeReactViewGroup? = lastCreatedView?.get()
+}
+
 @Suppress("detekt:TooManyFunctions")
 @SuppressLint("ViewConstructor")
 class EdgeToEdgeReactViewGroup(
@@ -58,7 +69,7 @@ class EdgeToEdgeReactViewGroup(
   private val modalAttachedWatcher = ModalAttachedWatcher(this, reactContext, config, ::getKeyboardCallback)
 
   init {
-    tag = VIEW_TAG
+    EdgeToEdgeViewRegistry.register(this)
   }
 
   // region View life cycles
@@ -241,8 +252,4 @@ class EdgeToEdgeReactViewGroup(
     }
   }
   // endregion
-
-  companion object {
-    val VIEW_TAG = EdgeToEdgeReactViewGroup::class.simpleName
-  }
 }

package/ios/observers/movement/KeyboardTrackingView.swift

@@ -0,0 +1,139 @@
+//
+//  KeyboardTrackingView.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 25/07/2025.
+//
+
+import UIKit
+
+/**
+ * A compatibility view that resolves to `KeyboardView` on iOS < 26
+ * and uses `keyboardLayoutGuide` on iOS 26+.
+ */
+final class KeyboardTrackingView: UIView {
+  private var keyboardView: UIView? { KeyboardViewLocator.shared.resolve() }
+  private var keyboardHeight = 0.0
+
+  static let invalidPosition: CGFloat = -.greatestFiniteMagnitude
+
+  override init(frame: CGRect) {
+    super.init(frame: frame)
+    setup()
+  }
+
+  required init?(coder: NSCoder) {
+    super.init(coder: coder)
+    setup()
+  }
+
+  required init() {
+    super.init(frame: .zero)
+    setup()
+  }
+
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+
+  private func setup() {
+    // for debug purposes
+    // self.backgroundColor = .red
+    isUserInteractionEnabled = false
+    isHidden = true
+
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(keyboardWillAppear),
+      name: UIResponder.keyboardWillShowNotification,
+      object: nil
+    )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(keyboardDidAppear),
+      name: UIResponder.keyboardDidShowNotification,
+      object: nil
+    )
+
+    guard
+      let window = UIApplication.shared.activeWindow,
+      let rootView = window.rootViewController?.view
+    else {
+      return
+    }
+
+    rootView.addSubview(self)
+
+    translatesAutoresizingMaskIntoConstraints = false
+
+    if #available(iOS 15.0, *) {
+      if #available(iOS 17.0, *) {
+        rootView.keyboardLayoutGuide.usesBottomSafeArea = false
+      }
+
+      NSLayoutConstraint.activate([
+        leadingAnchor.constraint(equalTo: rootView.leadingAnchor, constant: 0),
+        trailingAnchor.constraint(equalTo: rootView.trailingAnchor, constant: 0),
+        bottomAnchor.constraint(equalTo: rootView.keyboardLayoutGuide.topAnchor, constant: 0),
+        heightAnchor.constraint(equalToConstant: 0),
+      ])
+    }
+  }
+
+  @objc private func keyboardWillAppear(_ notification: Notification) {
+    updateHeightFromNotification(notification)
+  }
+
+  @objc private func keyboardDidAppear(_ notification: Notification) {
+    updateHeightFromNotification(notification)
+  }
+
+  private func updateHeightFromNotification(_ notification: Notification) {
+    let (_, frame) = notification.keyboardMetaData()
+    if let keyboardFrame = frame {
+      let keyboardHeight = keyboardFrame.cgRectValue.size.height
+      self.keyboardHeight = keyboardHeight
+    }
+  }
+
+  @objc var view: UIView? {
+    if #available(iOS 26.0, *) {
+      return self
+    } else {
+      return keyboardView
+    }
+  }
+
+  func interactive(point: CGPoint) -> CGFloat {
+    guard let trackedView = view else { return Self.invalidPosition }
+
+    let keyboardFrameY = point.y
+    let keyboardWindowH = trackedView.window?.bounds.size.height ?? 0
+    let keyboardPosition = keyboardWindowH - keyboardFrameY
+
+    // for `keyboardLayoutGuide` case we can just read keyboard position directly - no interpolation needed
+    if #available(iOS 26.0, *) {
+      // when we are the top position KVO takes `inputAccessoryView` into consideration,
+      // so we handle it here
+      if keyboardPosition == keyboardHeight {
+        return keyboardPosition - KeyboardAreaExtender.shared.offset
+      }
+      return keyboardPosition
+    }
+
+    // if keyboard height is not equal to its bounds - we can ignore
+    // values, since they'll be invalid and will cause UI jumps
+    // valid only for non-`keyboardLayoutGuide` case
+    if floor(trackedView.bounds.size.height) != floor(keyboardHeight) {
+      return Self.invalidPosition
+    }
+
+    let position = CGFloat.interpolate(
+      inputRange: [keyboardHeight / 2, -keyboardHeight / 2],
+      outputRange: [keyboardHeight, 0],
+      currentValue: keyboardPosition
+    )
+
+    return position - KeyboardAreaExtender.shared.offset
+  }
+}

package/ios/observers/movement/KeyboardViewLocator.swift

@@ -0,0 +1,23 @@
+//
+//  KeyboardViewLocator.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 25/07/2025.
+//
+
+final class KeyboardViewLocator {
+  static let shared = KeyboardViewLocator()
+  private var cachedKeyboardView: UIView?
+  private var cachedWindowsCount: Int = 0
+
+  func resolve() -> UIView? {
+    let currentWindowsCount = UIApplication.shared.windows.count
+
+    if cachedKeyboardView == nil || currentWindowsCount != cachedWindowsCount {
+      cachedKeyboardView = KeyboardView.find()
+      cachedWindowsCount = currentWindowsCount
+    }
+
+    return cachedKeyboardView
+  }
+}

package/ios/observers/movement/observer/KeyboardMovementObserver+Animation.swift

@@ -0,0 +1,21 @@
+//
+//  KeyboardMovementObserver+Animation.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 07/08/2025.
+//
+
+extension KeyboardMovementObserver {
+  func initializeAnimation(fromValue: Double, toValue: Double) {
+    for key in ["position", "opacity"] {
+      if let keyboardAnimation = keyboardTrackingView.view?.layer.presentation()?.animation(forKey: key) {
+        if let springAnimation = keyboardAnimation as? CASpringAnimation {
+          animation = SpringAnimation(animation: springAnimation, fromValue: fromValue, toValue: toValue)
+        } else if let basicAnimation = keyboardAnimation as? CABasicAnimation {
+          animation = TimingAnimation(animation: basicAnimation, fromValue: fromValue, toValue: toValue)
+        }
+        return
+      }
+    }
+  }
+}

package/ios/observers/movement/observer/KeyboardMovementObserver+Interactive.swift

@@ -0,0 +1,56 @@
+//
+//  KeyboardMovementObserver+Interactive.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 07/08/2025.
+//
+
+extension KeyboardMovementObserver {
+  func setupKVObserver() {
+    guard interactiveKeyboardObserver == nil, let view = keyboardTrackingView.view else { return }
+
+    interactiveKeyboardObserver = view.observe(\.center, options: .new) { [weak self] _, change in
+      guard let self = self, let changeValue = change.newValue else { return }
+
+      self.keyboardDidMoveInteractively(changeValue: changeValue)
+    }
+  }
+
+  func removeKVObserver() {
+    interactiveKeyboardObserver?.invalidate()
+    interactiveKeyboardObserver = nil
+  }
+
+  private func keyboardDidMoveInteractively(changeValue: CGPoint) {
+    if UIResponder.isKeyboardPreloading {
+      return
+    }
+    // if we are currently animating keyboard -> we need to ignore values from KVO
+    if !displayLink.isPaused {
+      return
+    }
+
+    let position = keyboardTrackingView.interactive(point: changeValue)
+
+    if position == KeyboardTrackingView.invalidPosition {
+      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
+
+    onEvent(
+      "onKeyboardMoveInteractive",
+      position as NSNumber,
+      position / CGFloat(keyboardHeight) as NSNumber,
+      -1,
+      tag
+    )
+  }
+}

package/ios/observers/movement/observer/KeyboardMovementObserver+Lifecycle.swift

@@ -0,0 +1,47 @@
+//
+//  KeyboardMovementObserver+Lifecycle.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 07/08/2025.
+//
+
+public extension KeyboardMovementObserver {
+  @objc func mount() {
+    if isMounted {
+      return
+    }
+
+    isMounted = true
+
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(keyboardWillDisappear),
+      name: UIResponder.keyboardWillHideNotification,
+      object: nil
+    )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(keyboardWillAppear),
+      name: UIResponder.keyboardWillShowNotification,
+      object: nil
+    )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(keyboardDidAppear),
+      name: UIResponder.keyboardDidShowNotification,
+      object: nil
+    )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(keyboardDidDisappear),
+      name: UIResponder.keyboardDidHideNotification,
+      object: nil
+    )
+  }
+
+  @objc func unmount() {
+    isMounted = false
+    // swiftlint:disable:next notification_center_detachment
+    NotificationCenter.default.removeObserver(self)
+  }
+}

package/ios/observers/movement/observer/KeyboardMovementObserver+Listeners.swift

@@ -0,0 +1,88 @@
+//
+//  KeyboardMovementObserver+Listeners.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 07/08/2025.
+//
+
+extension KeyboardMovementObserver {
+  @objc func keyboardWillAppear(_ notification: Notification) {
+    guard !KeyboardEventsIgnorer.shared.shouldIgnore, !UIResponder.isKeyboardPreloading else { return }
+
+    let (duration, frame) = notification.keyboardMetaData()
+    if let keyboardFrame = frame {
+      tag = UIResponder.current.reactViewTag
+      let keyboardHeight = keyboardFrame.cgRectValue.size.height
+      self.keyboardHeight = keyboardHeight
+      self.duration = duration
+      didShowDeadline = Date.currentTimeStamp + Int64(duration)
+
+      onRequestAnimation()
+      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: self.keyboardHeight)
+    }
+  }
+
+  @objc func keyboardWillDisappear(_ notification: Notification) {
+    guard !UIResponder.isKeyboardPreloading else { return }
+    let (duration, _) = notification.keyboardMetaData()
+    tag = UIResponder.current.reactViewTag
+    self.duration = duration
+
+    onRequestAnimation()
+    onEvent("onKeyboardMoveStart", 0, 0, duration as NSNumber, tag)
+    onNotify("KeyboardController::keyboardWillHide", buildEventParams(0, duration, tag))
+
+    setupKeyboardWatcher()
+    removeKVObserver()
+    initializeAnimation(fromValue: prevKeyboardPosition, toValue: 0)
+  }
+
+  @objc func keyboardDidAppear(_ notification: Notification) {
+    guard !UIResponder.isKeyboardPreloading else { return }
+
+    let timestamp = Date.currentTimeStamp
+    let (duration, frame) = notification.keyboardMetaData()
+    if let keyboardFrame = frame {
+      let (position, _) = keyboardTrackingView.view.frameTransitionInWindow
+      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 ? self.keyboardHeight : position - KeyboardAreaExtender.shared.offset
+      // always limit progress to the maximum possible value
+      let progress = min(height / self.keyboardHeight, 1.0)
+
+      onCancelAnimation()
+      onEvent("onKeyboardMoveEnd", height as NSNumber, progress as NSNumber, duration as NSNumber, tag)
+      onNotify("KeyboardController::keyboardDidShow", buildEventParams(height, duration, tag))
+
+      removeKeyboardWatcher()
+      setupKVObserver()
+      animation = nil
+    }
+  }
+
+  @objc func keyboardDidDisappear(_ notification: Notification) {
+    guard !UIResponder.isKeyboardPreloading else { return }
+    let (duration, _) = notification.keyboardMetaData()
+    tag = UIResponder.current.reactViewTag
+
+    onCancelAnimation()
+    onEvent("onKeyboardMoveEnd", 0 as NSNumber, 0, duration as NSNumber, tag)
+    onNotify("KeyboardController::keyboardDidHide", buildEventParams(0, duration, tag))
+
+    removeKeyboardWatcher()
+    animation = nil
+  }
+}

package/ios/observers/movement/observer/KeyboardMovementObserver+Watcher.swift

@@ -0,0 +1,72 @@
+//
+//  KeyboardMovementObserver+Watcher.swift
+//  Pods
+//
+//  Created by Kiryl Ziusko on 07/08/2025.
+//
+
+extension KeyboardMovementObserver {
+  @objc func setupKeyboardWatcher() {
+    // sometimes `will` events can be called multiple times.
+    // To avoid double re-creation of listener we are adding this condition
+    // (if active link is present, then no need to re-setup a listener)
+    if !displayLink.isPaused {
+      return
+    }
+
+    displayLink.isPaused = false
+  }
+
+  @objc func removeKeyboardWatcher() {
+    displayLink.isPaused = true
+  }
+
+  @objc func updateKeyboardFrame(link: CADisplayLink) {
+    if keyboardTrackingView.view == nil {
+      return
+    }
+
+    let (visibleKeyboardHeight, keyboardFrameY) = keyboardTrackingView.view.frameTransitionInWindow
+    var keyboardPosition = visibleKeyboardHeight - KeyboardAreaExtender.shared.offset
+
+    if keyboardPosition == prevKeyboardPosition || keyboardFrameY == 0 {
+      return
+    }
+
+    if animation == nil {
+      initializeAnimation(fromValue: prevKeyboardPosition, toValue: keyboardHeight)
+    }
+
+    prevKeyboardPosition = keyboardPosition
+
+    if let animation = animation {
+      let baseDuration = animation.timingAt(value: keyboardPosition)
+
+      #if targetEnvironment(simulator)
+        // on iOS simulator we can not use static interval
+        // (from my observation from frame to frame we may have different delays)
+        // so for now we use approximation - we add a difference as
+        // beginTime - keyboardEventTime (but only in 0..0.016 range)
+        // and it gives satisfactory results (better than static delays)
+        let duration = baseDuration + animation.diff
+      #else
+        // 2 frames because we read previous frame, but need to calculate the next frame
+        let duration = baseDuration + link.duration * 2
+      #endif
+
+      let position = CGFloat(animation.valueAt(time: duration))
+      // handles a case when final frame has final destination (i. e. 0 or 291)
+      // but CASpringAnimation can never get to this final destination
+      let race: (CGFloat, CGFloat) -> CGFloat = animation.isIncreasing ? max : min
+      keyboardPosition = race(position, keyboardPosition)
+    }
+
+    onEvent(
+      "onKeyboardMove",
+      keyboardPosition as NSNumber,
+      keyboardPosition / CGFloat(keyboardHeight) as NSNumber,
+      duration as NSNumber,
+      tag
+    )
+  }
+}

package/ios/observers/movement/observer/KeyboardMovementObserver.swift

@@ -0,0 +1,63 @@
+//
+//  KeyboardMovementObserver.swift
+//  KeyboardController
+//
+//  Created by Kiryl Ziusko on 2.08.22.
+//  Copyright © 2022 Facebook. All rights reserved.
+//
+
+import Foundation
+import UIKit
+
+@objc(KeyboardMovementObserver)
+public class KeyboardMovementObserver: NSObject {
+  // class members
+  var onEvent: (NSString, NSNumber, NSNumber, NSNumber, NSNumber) -> Void
+  var onNotify: (String, Any) -> Void
+  // animation
+  var onRequestAnimation: () -> Void
+  var onCancelAnimation: () -> Void
+  // progress tracker
+  var keyboardTrackingView = KeyboardTrackingView()
+  var animation: KeyboardAnimation?
+
+  var prevKeyboardPosition = 0.0
+  var displayLink: CADisplayLink!
+  var interactiveKeyboardObserver: NSKeyValueObservation?
+  var isMounted = false
+  // state variables
+  private var _keyboardHeight: CGFloat = 0.0
+  var keyboardHeight: CGFloat {
+    get { _keyboardHeight - KeyboardAreaExtender.shared.offset }
+    set { _keyboardHeight = newValue }
+  }
+
+  var duration = 0
+  var tag: NSNumber = -1
+  var didShowDeadline: Int64 = 0
+
+  @objc public init(
+    handler: @escaping (NSString, NSNumber, NSNumber, NSNumber, NSNumber) -> Void,
+    onNotify: @escaping (String, Any) -> Void,
+    onRequestAnimation: @escaping () -> Void,
+    onCancelAnimation: @escaping () -> Void
+  ) {
+    onEvent = handler
+    self.onNotify = onNotify
+    self.onRequestAnimation = onRequestAnimation
+    self.onCancelAnimation = onCancelAnimation
+
+    super.init()
+
+    displayLink = CADisplayLink(target: self, selector: #selector(updateKeyboardFrame))
+    displayLink.preferredFramesPerSecond = 120 // will fallback to 60 fps for devices without Pro Motion display
+    displayLink.add(to: .main, forMode: .common)
+    displayLink.isPaused = true
+  }
+
+  deinit {
+    displayLink.invalidate()
+    displayLink = nil
+    NotificationCenter.default.removeObserver(self)
+  }
+}

package/ios/views/KeyboardControllerView.mm

@@ -178,16 +178,16 @@ using namespace facebook::react;
                           .duration = [duration intValue],
                           .target = [target intValue]});
             }
-          }
-          if ([event isEqualToString:@"onKeyboardMoveInteractive"]) {
-            std::dynamic_pointer_cast<const facebook::react::KeyboardControllerViewEventEmitter>(
-                self->_eventEmitter)
-                ->onKeyboardMoveInteractive(
-                    facebook::react::KeyboardControllerViewEventEmitter::OnKeyboardMoveInteractive{
-                        .height = [height doubleValue],
-                        .progress = [progress doubleValue],
-                        .duration = [duration intValue],
-                        .target = [target intValue]});
+            if ([event isEqualToString:@"onKeyboardMoveInteractive"]) {
+              std::dynamic_pointer_cast<const facebook::react::KeyboardControllerViewEventEmitter>(
+                  self->_eventEmitter)
+                  ->onKeyboardMoveInteractive(facebook::react::KeyboardControllerViewEventEmitter::
+                                                  OnKeyboardMoveInteractive{
+                                                      .height = [height doubleValue],
+                                                      .progress = [progress doubleValue],
+                                                      .duration = [duration intValue],
+                                                      .target = [target intValue]});
+            }
           }
 
           KeyboardMoveEvent *keyboardMoveEvent =