react-native-keyboard-controller 1.18.3 → 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/{KeyboardTrackingView.swift → movement/KeyboardTrackingView.swift}

@@ -66,16 +66,18 @@ final class KeyboardTrackingView: UIView {
 
     translatesAutoresizingMaskIntoConstraints = false
 
-    if #available(iOS 17.0, *) {
-      rootView.keyboardLayoutGuide.usesBottomSafeArea = 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),
+      ])
     }
-
-    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) {
@@ -111,6 +113,11 @@ final class KeyboardTrackingView: UIView {
 
     // 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
     }
 
@@ -127,6 +134,6 @@ final class KeyboardTrackingView: UIView {
       currentValue: keyboardPosition
     )
 
-    return position
+    return position - KeyboardAreaExtender.shared.offset
   }
 }

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/KeyboardExtenderContainerView.swift

@@ -10,11 +10,13 @@ import UIKit
 @objc
 public class KeyboardExtenderContainerView: NSObject {
   @objc public static func create(frame: CGRect, contentView: UIView) -> UIView {
-    if #available(iOS 26.0, *) {
-      return ModernContainerView(frame: frame, contentView: contentView)
-    } else {
-      return LegacyContainerView(frame: frame, contentView: contentView)
-    }
+    #if canImport(UIKit.UIGlassEffect)
+      if #available(iOS 26.0, *) {
+        return ModernContainerView(frame: frame, contentView: contentView)
+      }
+    #endif
+
+    return LegacyContainerView(frame: frame, contentView: contentView)
   }
 }
 
@@ -86,21 +88,23 @@ private class ModernContainerView: BaseContainerView {
   }
 
   private func setupVisualEffect() {
-    guard let glassEffectClass = NSClassFromString("UIGlassEffect") as? UIVisualEffect.Type else { return }
-
-    let isDark = FocusedInputHolder.shared.get()?.keyboardAppearanceValue == "dark"
-    let glassEffect = glassEffectClass.init()
-    let color = isDark ? UIColor.black.withAlphaComponent(0.3) : UIColor.gray.withAlphaComponent(0.3)
-    glassEffect.setValue(color, forKey: "tintColor")
-    glassEffect.setValue(true, forKey: "interactive")
-
-    visualEffectView = UIVisualEffectView(effect: glassEffect)
-    visualEffectView?.overrideUserInterfaceStyle = isDark ? .dark : .light
-
-    if let visualEffectView = visualEffectView {
-      visualEffectView.contentView.addSubview(contentView)
-      addSubview(visualEffectView)
-    }
+    #if canImport(UIKit.UIGlassEffect)
+      let isDark = FocusedInputHolder.shared.get()?.keyboardAppearanceValue == "dark"
+      let glassEffect = UIGlassEffect()
+      let color =
+        isDark ? UIColor.black.withAlphaComponent(0.3) : UIColor.gray.withAlphaComponent(0.3)
+      glassEffect.tintColor = color
+      glassEffect.isInteractive = true
+
+      visualEffectView = UIVisualEffectView(effect: glassEffect)
+      visualEffectView?.overrideUserInterfaceStyle = isDark ? .dark : .light
+      visualEffectView?.cornerConfiguration = .capsule()
+
+      if let visualEffectView = visualEffectView {
+        visualEffectView.contentView.addSubview(contentView)
+        addSubview(visualEffectView)
+      }
+    #endif
   }
 
   override func updateContentFrame(desiredHeight: CGFloat) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-keyboard-controller",
-  "version": "1.18.3",
+  "version": "1.18.4",
   "description": "Keyboard manager which works in identical way on both iOS and Android",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/ios/observers/KeyboardMovementObserver.swift

@@ -1,307 +0,0 @@
-//
-//  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
-  private var keyboardTrackingView = KeyboardTrackingView()
-
-  private var prevKeyboardPosition = 0.0
-  private var displayLink: CADisplayLink!
-  private var interactiveKeyboardObserver: NSKeyValueObservation?
-  private var isMounted = false
-  // state variables
-  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?
-  private 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
-  }
-
-  @objc public 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
-    )
-  }
-
-  private 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)
-    }
-  }
-
-  private 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 interactive = keyboardTrackingView.interactive(point: changeValue)
-
-    if interactive == KeyboardTrackingView.invalidPosition {
-      return
-    }
-    let position = interactive - KeyboardAreaExtender.shared.offset
-
-    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
-    )
-  }
-
-  @objc public func unmount() {
-    isMounted = false
-    // swiftlint:disable:next notification_center_detachment
-    NotificationCenter.default.removeObserver(self)
-  }
-
-  @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
-  }
-
-  @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
-  }
-
-  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
-      }
-    }
-  }
-
-  @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
-    )
-  }
-}