react-native-keyboard-controller 1.5.7 → 1.6.0

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

@@ -24,6 +24,7 @@ val interpolators = mapOf(
   "ios" to IosInterpolator(),
 )
 
+@Suppress("detekt:TooManyFunctions")
 @SuppressLint("ViewConstructor")
 class KeyboardGestureAreaReactViewGroup(private val reactContext: ThemedReactContext) : ReactViewGroup(reactContext) {
   // internal state management
@@ -31,6 +32,7 @@ class KeyboardGestureAreaReactViewGroup(private val reactContext: ThemedReactCon
   private var lastTouchX = 0f
   private var lastTouchY = 0f
   private var lastWindowY = 0
+  private var keyboardHeight = 0
 
   // react props
   private var interpolator: Interpolator = LinearInterpolator()
@@ -51,96 +53,16 @@ class KeyboardGestureAreaReactViewGroup(private val reactContext: ThemedReactCon
     }
 
     when (event?.action) {
-      MotionEvent.ACTION_DOWN -> {
-        velocityTracker?.addMovement(event)
-
-        lastTouchX = event.x
-        lastTouchY = event.y
-
-        this.copyBoundsInWindow(bounds)
-        lastWindowY = bounds.top
-      }
-      MotionEvent.ACTION_MOVE -> {
-        // Since the view is likely to be translated/moved as the WindowInsetsAnimation
-        // progresses, we need to make sure we account for that change in our touch
-        // handling. We do that by keeping track of the view's Y position in the window,
-        // and detecting the difference between the current bounds.
-        this.copyBoundsInWindow(bounds)
-        val windowOffsetY = bounds.top - lastWindowY
-
-        // We then make a copy of the MotionEvent, and offset it with the calculated
-        // windowOffsetY. We can then pass it to the VelocityTracker.
-        val velocityTrackerEvent = MotionEvent.obtain(event)
-        velocityTrackerEvent.offsetLocation(0f, windowOffsetY.toFloat())
-        velocityTracker?.addMovement(velocityTrackerEvent)
-
-        val dx = velocityTrackerEvent.x - lastTouchX
-        val dy = velocityTrackerEvent.y - lastTouchY
-
-        if (!isHandling) {
-          // If we're not currently handling the touch gesture, lets check if we should
-          // start handling, by seeing if the gesture is majorly vertical, and
-          // larger than the touch slop
-          isHandling = dy.absoluteValue > dx.absoluteValue &&
-            dy.absoluteValue >= ViewConfiguration.get(this.context).scaledTouchSlop
-        }
-
-        if (isHandling) {
-          if (controller.isInsetAnimationInProgress()) {
-            // If we currently have control, we can update the IME insets to 'scroll'
-            // the IME in
-            val moveBy = this.interpolator.interpolate(dy.roundToInt(), this.getWindowHeight() - event.rawY.toInt(), controller.getCurrentKeyboardHeight())
-
-            if (moveBy != 0) {
-              controller.insetBy(moveBy)
-            }
-          } else if (
-            !controller.isInsetAnimationRequestPending() &&
-            shouldStartRequest(
-              dy = dy,
-              imeVisible = ViewCompat.getRootWindowInsets(this)
-                ?.isVisible(WindowInsetsCompat.Type.ime()) == true,
-            )
-          ) {
-            // If we don't currently have control (and a request isn't pending),
-            // the IME is not shown, the user is scrolling up, and the view can't
-            // scroll up any more (i.e. over-scrolling), we can start to control
-            // the IME insets
-            controller.startControlRequest(this)
-          }
-
-          // Lastly we record the event X, Y, and view's Y window position, for the
-          // next touch event
-          lastTouchY = event.y
-          lastTouchX = event.x
-          lastWindowY = bounds.top
-        }
-      }
-      MotionEvent.ACTION_UP -> {
-        velocityTracker?.addMovement(event)
-
-        // Calculate the current velocityY, over 500 milliseconds
-        velocityTracker?.computeCurrentVelocity(500)
-        val velocityY = velocityTracker?.yVelocity
-
-        // If we received a ACTION_UP event, end any current WindowInsetsAnimation passing
-        // in the calculated Y velocity
-        controller.animateToFinish(velocityY)
-
-        // Reset our touch handling state
-        reset()
-      }
-      MotionEvent.ACTION_CANCEL -> {
-        // If we received a ACTION_CANCEL event, cancel any current WindowInsetsAnimation
-        controller.cancel()
-        // Reset our touch handling state
-        reset()
-      }
+      MotionEvent.ACTION_DOWN -> this.onActionDown(event)
+      MotionEvent.ACTION_MOVE -> this.onActionMove(event)
+      MotionEvent.ACTION_UP -> this.onActionUp(event)
+      MotionEvent.ACTION_CANCEL -> this.onActionCancel()
     }
 
     return super.dispatchTouchEvent(event)
   }
 
+  // region Props setters
   fun setInterpolator(interpolator: String) {
     this.interpolator = interpolators[interpolator] ?: LinearInterpolator()
   }
@@ -152,6 +74,114 @@ class KeyboardGestureAreaReactViewGroup(private val reactContext: ThemedReactCon
   fun setScrollKeyboardOffScreenWhenVisible(scrollImeOffScreenWhenVisible: Boolean) {
     this.scrollKeyboardOffScreenWhenVisible = scrollImeOffScreenWhenVisible
   }
+  // endregion
+
+  // region Handlers
+  @RequiresApi(Build.VERSION_CODES.KITKAT)
+  private fun onActionDown(event: MotionEvent) {
+    velocityTracker?.addMovement(event)
+
+    lastTouchX = event.x
+    lastTouchY = event.y
+
+    this.copyBoundsInWindow(bounds)
+    lastWindowY = bounds.top
+  }
+
+  @RequiresApi(Build.VERSION_CODES.R)
+  private fun onActionMove(event: MotionEvent) {
+    // Since the view is likely to be translated/moved as the WindowInsetsAnimation
+    // progresses, we need to make sure we account for that change in our touch
+    // handling. We do that by keeping track of the view's Y position in the window,
+    // and detecting the difference between the current bounds.
+    this.copyBoundsInWindow(bounds)
+    val windowOffsetY = bounds.top - lastWindowY
+
+    // We then make a copy of the MotionEvent, and offset it with the calculated
+    // windowOffsetY. We can then pass it to the VelocityTracker.
+    val velocityTrackerEvent = MotionEvent.obtain(event)
+    velocityTrackerEvent.offsetLocation(0f, windowOffsetY.toFloat())
+    velocityTracker?.addMovement(velocityTrackerEvent)
+
+    val dx = velocityTrackerEvent.x - lastTouchX
+    val dy = velocityTrackerEvent.y - lastTouchY
+
+    if (!isHandling) {
+      // If we're not currently handling the touch gesture, lets check if we should
+      // start handling, by seeing if the gesture is majorly vertical, and
+      // larger than the touch slop
+      isHandling = dy.absoluteValue > dx.absoluteValue &&
+        dy.absoluteValue >= ViewConfiguration.get(this.context).scaledTouchSlop
+    }
+
+    if (isHandling) {
+      if (controller.isInsetAnimationInProgress()) {
+        if (keyboardHeight == 0) {
+          this.keyboardHeight = controller.getCurrentKeyboardHeight()
+        }
+        // If we currently have control, we can update the IME insets to 'scroll'
+        // the IME in
+        val moveBy = this.interpolator.interpolate(
+          dy.roundToInt(),
+          this.getWindowHeight() - event.rawY.toInt(),
+          controller.getCurrentKeyboardHeight(),
+        )
+
+        if (moveBy != 0) {
+          controller.insetBy(moveBy)
+        }
+      } else if (
+        !controller.isInsetAnimationRequestPending() &&
+        shouldStartRequest(
+          dy = dy,
+          imeVisible = ViewCompat.getRootWindowInsets(this)
+            ?.isVisible(WindowInsetsCompat.Type.ime()) == true,
+        )
+      ) {
+        // If we don't currently have control (and a request isn't pending),
+        // the IME is not shown, the user is scrolling up, and the view can't
+        // scroll up any more (i.e. over-scrolling), we can start to control
+        // the IME insets
+        controller.startControlRequest(this)
+      }
+
+      // Lastly we record the event X, Y, and view's Y window position, for the
+      // next touch event
+      lastTouchY = event.y
+      lastTouchX = event.x
+      lastWindowY = bounds.top
+    }
+  }
+
+  private fun onActionUp(event: MotionEvent) {
+    velocityTracker?.addMovement(event)
+    velocityTracker?.computeCurrentVelocity(VELOCITY_UNITS)
+
+    val velocityY = velocityTracker?.yVelocity
+    val isKeyboardPositionChanged =
+      // check `isInsetAnimationInProgress()` before, since direct usage of `getCurrentKeyboardHeight()`
+      // may throw exception
+      !controller.isInsetAnimationInProgress() ||
+        this.keyboardHeight != controller.getCurrentKeyboardHeight()
+    // if keyboard height was changed after finger movement -> we need to calculate final position
+    // and make an animated transition
+    val passedVelocityY = if (isKeyboardPositionChanged) velocityY else null
+
+    // If we received a ACTION_UP event, end any current WindowInsetsAnimation passing
+    // in the calculated Y velocity
+    controller.animateToFinish(passedVelocityY)
+
+    // Reset our touch handling state
+    reset()
+  }
+
+  private fun onActionCancel() {
+    // If we received a ACTION_CANCEL event, cancel any current WindowInsetsAnimation
+    controller.cancel()
+    // Reset our touch handling state
+    reset()
+  }
+  // endregion
 
   /**
    * Resets all of our internal state.
@@ -162,6 +192,7 @@ class KeyboardGestureAreaReactViewGroup(private val reactContext: ThemedReactCon
     lastTouchX = 0f
     lastTouchY = 0f
     lastWindowY = 0
+    keyboardHeight = 0
     bounds.setEmpty()
 
     velocityTracker?.recycle()
@@ -189,4 +220,9 @@ class KeyboardGestureAreaReactViewGroup(private val reactContext: ThemedReactCon
 
     return metrics?.bounds?.height() ?: 0
   }
+
+  companion object {
+    // Calculate the current velocity over 500 milliseconds
+    private const val VELOCITY_UNITS = 500
+  }
 }

package/android/src/paper/java/com/reactnativekeyboardcontroller/KeyboardControllerModule.kt

@@ -10,23 +10,25 @@ class KeyboardControllerModule(mReactContext: ReactApplicationContext) : ReactCo
 
   override fun getName(): String = KeyboardControllerModuleImpl.NAME
 
-  @ReactMethod(isBlockingSynchronousMethod = true)
+  @ReactMethod
   fun setInputMode(mode: Int) {
     module.setInputMode(mode)
   }
 
-  @ReactMethod(isBlockingSynchronousMethod = true)
+  @ReactMethod
   fun setDefaultMode() {
     module.setDefaultMode()
   }
 
+  @Suppress("detekt:UnusedParameter")
   @ReactMethod
   fun addListener(eventName: String?) {
-    /* Required for RN built-in Event Emitter Calls. */
+    // Required for RN built-in Event Emitter Calls
   }
 
+  @Suppress("detekt:UnusedParameter")
   @ReactMethod
   fun removeListeners(count: Int?) {
-    /* Required for RN built-in Event Emitter Calls. */
+    // Required for RN built-in Event Emitter Calls
   }
 }

package/android/src/paper/java/com/reactnativekeyboardcontroller/StatusBarManagerCompatModule.kt

@@ -7,7 +7,8 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.reactnativekeyboardcontroller.modules.StatusBarManagerCompatModuleImpl
 
-class StatusBarManagerCompatModule(private val mReactContext: ReactApplicationContext) : ReactContextBaseJavaModule(mReactContext) {
+class StatusBarManagerCompatModule(mReactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(mReactContext) {
   private val module = StatusBarManagerCompatModuleImpl(mReactContext)
 
   override fun getName(): String = StatusBarManagerCompatModuleImpl.NAME

package/ios/Extensions.swift

@@ -7,6 +7,7 @@
 //
 
 import Foundation
+import UIKit
 
 public extension CGFloat {
   static func interpolate(inputRange: [CGFloat], outputRange: [CGFloat], currentValue: CGFloat) -> CGFloat {
@@ -21,3 +22,33 @@ public extension CGFloat {
     return interpolatedValue
   }
 }
+
+public extension Date {
+  static var currentTimeStamp: Int64 {
+    return Int64(Date().timeIntervalSince1970 * 1000)
+  }
+}
+
+public extension UIResponder {
+  private weak static var _currentFirstResponder: UIResponder?
+
+  static var current: UIResponder? {
+    UIResponder._currentFirstResponder = nil
+    UIApplication.shared.sendAction(#selector(findFirstResponder(sender:)), to: nil, from: nil, for: nil)
+    return UIResponder._currentFirstResponder
+  }
+
+  @objc internal func findFirstResponder(sender _: AnyObject) {
+    UIResponder._currentFirstResponder = self
+  }
+}
+
+public extension Optional where Wrapped == UIResponder {
+  var reactViewTag: NSNumber {
+    #if KEYBOARD_CONTROLLER_NEW_ARCH_ENABLED
+      return ((self as? RCTUITextField)?.superview?.tag ?? -1) as NSNumber
+    #else
+      return (self as? RCTUITextField)?.superview?.reactTag ?? -1
+    #endif
+  }
+}

package/ios/KeyboardController-Bridging-Header.h

@@ -1 +1,2 @@
+#import <React/RCTUITextField.h>
 #import <React/RCTViewManager.h>

package/ios/KeyboardControllerView.mm

@@ -44,7 +44,12 @@ using namespace facebook::react;
     _props = defaultProps;
 
     observer = [[KeyboardMovementObserver alloc]
-        initWithHandler:^(NSString *event, NSNumber *height, NSNumber *progress) {
+        initWithHandler:^(
+            NSString *event,
+            NSNumber *height,
+            NSNumber *progress,
+            NSNumber *duration,
+            NSNumber *target) {
           if (self->_eventEmitter) {
             // TODO: use reflection to reduce code duplication?
             if ([event isEqualToString:@"onKeyboardMoveStart"]) {
@@ -52,21 +57,30 @@ using namespace facebook::react;
                   self->_eventEmitter)
                   ->onKeyboardMoveStart(
                       facebook::react::KeyboardControllerViewEventEmitter::OnKeyboardMoveStart{
-                          .height = [height doubleValue], .progress = [progress doubleValue]});
+                          .height = [height doubleValue],
+                          .progress = [progress doubleValue],
+                          .duration = [duration intValue],
+                          .target = [target intValue]});
             }
             if ([event isEqualToString:@"onKeyboardMove"]) {
               std::dynamic_pointer_cast<const facebook::react::KeyboardControllerViewEventEmitter>(
                   self->_eventEmitter)
                   ->onKeyboardMove(
                       facebook::react::KeyboardControllerViewEventEmitter::OnKeyboardMove{
-                          .height = [height doubleValue], .progress = [progress doubleValue]});
+                          .height = [height doubleValue],
+                          .progress = [progress doubleValue],
+                          .duration = [duration intValue],
+                          .target = [target intValue]});
             }
             if ([event isEqualToString:@"onKeyboardMoveEnd"]) {
               std::dynamic_pointer_cast<const facebook::react::KeyboardControllerViewEventEmitter>(
                   self->_eventEmitter)
                   ->onKeyboardMoveEnd(
                       facebook::react::KeyboardControllerViewEventEmitter::OnKeyboardMoveEnd{
-                          .height = [height doubleValue], .progress = [progress doubleValue]});
+                          .height = [height doubleValue],
+                          .progress = [progress doubleValue],
+                          .duration = [duration intValue],
+                          .target = [target intValue]});
             }
           }
           if ([event isEqualToString:@"onKeyboardMoveInteractive"]) {
@@ -74,7 +88,10 @@ using namespace facebook::react;
                 self->_eventEmitter)
                 ->onKeyboardMoveInteractive(
                     facebook::react::KeyboardControllerViewEventEmitter::OnKeyboardMoveInteractive{
-                        .height = [height doubleValue], .progress = [progress doubleValue]});
+                        .height = [height doubleValue],
+                        .progress = [progress doubleValue],
+                        .duration = [duration intValue],
+                        .target = [target intValue]});
           }
 
           // TODO: use built-in _eventEmitter once NativeAnimated module will use ModernEventemitter
@@ -84,7 +101,9 @@ using namespace facebook::react;
                 [[KeyboardMoveEvent alloc] initWithReactTag:@(self.tag)
                                                       event:event
                                                      height:height
-                                                   progress:progress];
+                                                   progress:progress
+                                                   duration:duration
+                                                     target:target];
             [bridge.eventDispatcher sendEvent:keyboardMoveEvent];
           }
         }

package/ios/KeyboardControllerViewManager.swift

@@ -46,7 +46,7 @@ class KeyboardControllerView: UIView {
     }
   }
 
-  func onEvent(event: NSString, height: NSNumber, progress: NSNumber) {
+  func onEvent(event: NSString, height: NSNumber, progress: NSNumber, duration: NSNumber, target: NSNumber) {
     // we don't want to send event to JS before the JS thread is ready
     if bridge.value(forKey: "_jsThread") == nil {
       return
@@ -56,7 +56,9 @@ class KeyboardControllerView: UIView {
         reactTag: reactTag,
         event: event as String,
         height: height,
-        progress: progress
+        progress: progress,
+        duration: duration,
+        target: target
       )
     )
   }

package/ios/KeyboardMoveEvent.h

@@ -14,6 +14,8 @@
 - (instancetype)initWithReactTag:(NSNumber *)reactTag
                            event:(NSString *)event
                           height:(NSNumber *)height
-                        progress:(NSNumber *)progress;
+                        progress:(NSNumber *)progress
+                        duration:(NSNumber *)duration
+                          target:(NSNumber *)target;
 
 @end

package/ios/KeyboardMoveEvent.m

@@ -12,6 +12,8 @@
 @implementation KeyboardMoveEvent {
   NSNumber *_progress;
   NSNumber *_height;
+  NSNumber *_duration;
+  NSNumber *_target;
   uint16_t _coalescingKey;
 }
 
@@ -22,6 +24,8 @@
                            event:(NSString *)event
                           height:(NSNumber *)height
                         progress:(NSNumber *)progress
+                        duration:(NSNumber *)duration
+                          target:(NSNumber *)target
 {
   RCTAssertParam(reactTag);
 
@@ -30,6 +34,8 @@
     _viewTag = reactTag;
     _progress = progress;
     _height = height;
+    _duration = duration;
+    _target = target;
     _coalescingKey = 0;
   }
   return self;
@@ -47,6 +53,8 @@ RCT_NOT_IMPLEMENTED(-(instancetype)init)
   NSDictionary *body = @{
     @"progress" : _progress,
     @"height" : _height,
+    @"duration" : _duration,
+    @"target" : _target,
   };
 
   return body;

package/ios/KeyboardMovementObserver.swift

@@ -7,11 +7,12 @@
 //
 
 import Foundation
+import UIKit
 
 @objc(KeyboardMovementObserver)
 public class KeyboardMovementObserver: NSObject {
   // class members
-  var onEvent: (NSString, NSNumber, NSNumber) -> Void
+  var onEvent: (NSString, NSNumber, NSNumber, NSNumber, NSNumber) -> Void
   var onNotify: (String, Any) -> Void
   // progress tracker
   private var _keyboardView: UIView?
@@ -29,11 +30,14 @@ public class KeyboardMovementObserver: NSObject {
   private var _windowsCount: Int = 0
   private var prevKeyboardPosition = 0.0
   private var displayLink: CADisplayLink?
-  private var keyboardHeight: CGFloat = 0.0
   private var hasKVObserver = false
+  // state variables
+  private var keyboardHeight: CGFloat = 0.0
+  private var duration = 0
+  private var tag: NSNumber = -1
 
   @objc public init(
-    handler: @escaping (NSString, NSNumber, NSNumber) -> Void,
+    handler: @escaping (NSString, NSNumber, NSNumber, NSNumber, NSNumber) -> Void,
     onNotify: @escaping (String, Any) -> Void
   ) {
     onEvent = handler
@@ -100,6 +104,11 @@ public class KeyboardMovementObserver: NSObject {
       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
+      }
 
       // swiftlint:disable:next force_cast
       let keyboardFrameY = (change?[.newKey] as! NSValue).cgPointValue.y
@@ -118,7 +127,13 @@ public class KeyboardMovementObserver: NSObject {
         return
       }
 
-      onEvent("onKeyboardMoveInteractive", position as NSNumber, position / CGFloat(keyboardHeight) as NSNumber)
+      onEvent(
+        "onKeyboardMoveInteractive",
+        position as NSNumber,
+        position / CGFloat(keyboardHeight) as NSNumber,
+        -1,
+        tag
+      )
     }
   }
 
@@ -129,24 +144,41 @@ public class KeyboardMovementObserver: NSObject {
 
   @objc func keyboardWillAppear(_ notification: Notification) {
     if let keyboardFrame: NSValue = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue {
+      tag = UIResponder.current.reactViewTag
       let keyboardHeight = keyboardFrame.cgRectValue.size.height
+      let duration = Int(
+        (notification.userInfo?[UIResponder.keyboardAnimationDurationUserInfoKey] as? Double ?? 0) * 1000
+      )
       self.keyboardHeight = keyboardHeight
+      self.duration = duration
 
       var data = [AnyHashable: Any]()
       data["height"] = keyboardHeight
+      data["duration"] = duration
+      data["timestamp"] = Date.currentTimeStamp
+      data["target"] = tag
 
-      onEvent("onKeyboardMoveStart", Float(keyboardHeight) as NSNumber, 1)
+      onEvent("onKeyboardMoveStart", Float(keyboardHeight) as NSNumber, 1, duration as NSNumber, tag)
       onNotify("KeyboardController::keyboardWillShow", data)
 
       setupKeyboardWatcher()
     }
   }
 
-  @objc func keyboardWillDisappear() {
+  @objc func keyboardWillDisappear(_ notification: Notification) {
+    let duration = Int(
+      (notification.userInfo?[UIResponder.keyboardAnimationDurationUserInfoKey] as? Double ?? 0) * 1000
+    )
+    tag = UIResponder.current.reactViewTag
+    self.duration = duration
+
     var data = [AnyHashable: Any]()
     data["height"] = 0
+    data["duration"] = duration
+    data["timestamp"] = Date.currentTimeStamp
+    data["target"] = tag
 
-    onEvent("onKeyboardMoveStart", 0, 0)
+    onEvent("onKeyboardMoveStart", 0, 0, duration as NSNumber, tag)
     onNotify("KeyboardController::keyboardWillHide", data)
 
     setupKeyboardWatcher()
@@ -156,12 +188,19 @@ public class KeyboardMovementObserver: NSObject {
   @objc func keyboardDidAppear(_ notification: Notification) {
     if let keyboardFrame: NSValue = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue {
       let keyboardHeight = keyboardFrame.cgRectValue.size.height
+      tag = UIResponder.current.reactViewTag
       self.keyboardHeight = keyboardHeight
+      let duration = Int(
+        (notification.userInfo?[UIResponder.keyboardAnimationDurationUserInfoKey] as? Double ?? 0) * 1000
+      )
 
       var data = [AnyHashable: Any]()
       data["height"] = keyboardHeight
+      data["duration"] = duration
+      data["timestamp"] = Date.currentTimeStamp
+      data["target"] = tag
 
-      onEvent("onKeyboardMoveEnd", keyboardHeight as NSNumber, 1)
+      onEvent("onKeyboardMoveEnd", keyboardHeight as NSNumber, 1, duration as NSNumber, tag)
       onNotify("KeyboardController::keyboardDidShow", data)
 
       removeKeyboardWatcher()
@@ -169,11 +208,18 @@ public class KeyboardMovementObserver: NSObject {
     }
   }
 
-  @objc func keyboardDidDisappear() {
+  @objc func keyboardDidDisappear(_ notification: Notification) {
+    let duration = Int(
+      (notification.userInfo?[UIResponder.keyboardAnimationDurationUserInfoKey] as? Double ?? 0) * 1000
+    )
+    tag = UIResponder.current.reactViewTag
     var data = [AnyHashable: Any]()
     data["height"] = 0
+    data["duration"] = duration
+    data["timestamp"] = Date.currentTimeStamp
+    data["target"] = tag
 
-    onEvent("onKeyboardMoveEnd", 0 as NSNumber, 0)
+    onEvent("onKeyboardMoveEnd", 0 as NSNumber, 0, duration as NSNumber, tag)
     onNotify("KeyboardController::keyboardDidHide", data)
 
     removeKeyboardWatcher()
@@ -208,7 +254,7 @@ public class KeyboardMovementObserver: NSObject {
           if subview.description.hasPrefix("<UIInputSetContainerView") {
             for hostView in subview.subviews {
               if hostView.description.hasPrefix("<UIInputSetHostView") {
-                result = hostView as? UIView
+                result = hostView
                 break
               }
             }
@@ -235,6 +281,12 @@ public class KeyboardMovementObserver: NSObject {
     }
 
     prevKeyboardPosition = keyboardPosition
-    onEvent("onKeyboardMove", keyboardPosition as NSNumber, keyboardPosition / CGFloat(keyboardHeight) as NSNumber)
+    onEvent(
+      "onKeyboardMove",
+      keyboardPosition as NSNumber,
+      keyboardPosition / CGFloat(keyboardHeight) as NSNumber,
+      duration as NSNumber,
+      tag
+    )
   }
 }

package/lib/commonjs/animated.js

@@ -9,10 +9,11 @@ var _reactNative = require("react-native");
 var _reactNativeReanimated = _interopRequireWildcard(require("react-native-reanimated"));
 var _context = require("./context");
 var _internal = require("./internal");
-var _native = require("./native");
+var _bindings = require("./bindings");
+var _reanimated = require("./reanimated");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-const KeyboardControllerViewAnimated = _reactNativeReanimated.default.createAnimatedComponent(_reactNative.Animated.createAnimatedComponent(_native.KeyboardControllerView));
+const KeyboardControllerViewAnimated = _reactNativeReanimated.default.createAnimatedComponent(_reactNative.Animated.createAnimatedComponent(_bindings.KeyboardControllerView));
 const styles = _reactNative.StyleSheet.create({
   container: {
     flex: 1
@@ -74,7 +75,7 @@ const KeyboardProvider = _ref => {
       heightSV.value = -event.height;
     }
   };
-  const handler = (0, _internal.useAnimatedKeyboardHandler)({
+  const handler = (0, _reanimated.useAnimatedKeyboardHandler)({
     onKeyboardMoveStart: event => {
       'worklet';