react-native-keyboard-controller 1.4.4 → 1.5.1

package/android/src/main/java/com/reactnativekeyboardcontroller/extensions/Float.kt

@@ -2,7 +2,7 @@ package com.reactnativekeyboardcontroller.extensions
 
 import android.content.res.Resources
 
-val Float.dp: Int
-  get() = (this / Resources.getSystem().displayMetrics.density).toInt()
-val Float.px: Int
-  get() = (this * Resources.getSystem().displayMetrics.density).toInt()
+val Float.dp: Double
+  get() = (this / Resources.getSystem().displayMetrics.density).toDouble()
+val Float.px: Double
+  get() = (this * Resources.getSystem().displayMetrics.density).toDouble()

package/android/src/main/java/com/reactnativekeyboardcontroller/extensions/View.kt

@@ -1,7 +1,9 @@
 package com.reactnativekeyboardcontroller.extensions
 
+import android.graphics.Rect
 import android.os.Build
 import android.view.View
+import androidx.annotation.RequiresApi
 
 /**
  * Call this everytime when using [ViewCompat.setOnApplyWindowInsetsListener]
@@ -27,3 +29,22 @@ fun View.requestApplyInsetsWhenAttached() {
     })
   }
 }
+
+private val tmpIntArr = IntArray(2)
+
+/**
+ * Function which updates the given [rect] with this view's position and bounds in its window.
+ */
+@RequiresApi(Build.VERSION_CODES.KITKAT)
+fun View.copyBoundsInWindow(rect: Rect) {
+  if (isLaidOut && isAttachedToWindow) {
+    rect.set(0, 0, width, height)
+    getLocationInWindow(tmpIntArr)
+    rect.offset(tmpIntArr[0], tmpIntArr[1])
+  } else {
+    throw IllegalArgumentException(
+      "Can not copy bounds as view is not laid out" +
+        " or attached to window",
+    )
+  }
+}

package/android/src/main/java/com/reactnativekeyboardcontroller/interpolators/Interpolator.kt

@@ -0,0 +1,14 @@
+package com.reactnativekeyboardcontroller.interpolators
+
+interface Interpolator {
+  /**
+   * A function that allows you to control the layout of the keyboard
+   * depending on the position of the finger on the screen.
+   *
+   * @param dy the distance that the finger has moved relative to the previous location.
+   * @param absoluteFingerPosition current position of the finger.
+   * @param keyboardPosition current keyboard position.
+   * @return the distance the keyboard should be moved from its current location.
+   */
+  fun interpolate(dy: Int, absoluteFingerPosition: Int, keyboardPosition: Int): Int
+}

package/android/src/main/java/com/reactnativekeyboardcontroller/interpolators/IosInterpolator.kt

@@ -0,0 +1,18 @@
+package com.reactnativekeyboardcontroller.interpolators
+
+class IosInterpolator : Interpolator {
+  override fun interpolate(
+    dy: Int,
+    absoluteFingerPosition: Int,
+    keyboardPosition: Int,
+  ): Int {
+    if (
+      absoluteFingerPosition <= keyboardPosition || // user overscrolled keyboard
+      dy <= 0 // user scrolls up
+    ) {
+      return dy
+    }
+
+    return 0
+  }
+}

package/android/src/main/java/com/reactnativekeyboardcontroller/interpolators/LinearInterpolator.kt

@@ -0,0 +1,11 @@
+package com.reactnativekeyboardcontroller.interpolators
+
+class LinearInterpolator : Interpolator {
+  override fun interpolate(
+    dy: Int,
+    absoluteFingerPosition: Int,
+    keyboardPosition: Int,
+  ): Int {
+    return dy
+  }
+}

package/android/src/main/java/com/reactnativekeyboardcontroller/managers/KeyboardControllerViewManagerImpl.kt

@@ -74,6 +74,8 @@ class KeyboardControllerViewManagerImpl(private val mReactContext: ReactApplicat
       MapBuilder.of("registrationName", "onKeyboardMoveStart"),
       "topKeyboardMoveEnd",
       MapBuilder.of("registrationName", "onKeyboardMoveEnd"),
+      "topKeyboardMoveInteractive",
+      MapBuilder.of("registrationName", "onKeyboardMoveInteractive"),
     )
 
     return map

package/android/src/main/java/com/reactnativekeyboardcontroller/managers/KeyboardGestureAreaViewManagerImpl.kt

@@ -0,0 +1,27 @@
+package com.reactnativekeyboardcontroller.managers
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ThemedReactContext
+import com.reactnativekeyboardcontroller.views.KeyboardGestureAreaReactViewGroup
+
+class KeyboardGestureAreaViewManagerImpl(mReactContext: ReactApplicationContext) {
+  fun createViewInstance(reactContext: ThemedReactContext): KeyboardGestureAreaReactViewGroup {
+    return KeyboardGestureAreaReactViewGroup(reactContext)
+  }
+
+  fun setInterpolator(view: KeyboardGestureAreaReactViewGroup, interpolator: String) {
+    view.setInterpolator(interpolator)
+  }
+
+  fun setScrollKeyboardOffScreenWhenVisible(view: KeyboardGestureAreaReactViewGroup, value: Boolean) {
+    view.setScrollKeyboardOffScreenWhenVisible(value)
+  }
+
+  fun setScrollKeyboardOnScreenWhenNotVisible(view: KeyboardGestureAreaReactViewGroup, value: Boolean) {
+    view.setScrollKeyboardOnScreenWhenNotVisible(value)
+  }
+
+  companion object {
+    const val NAME = "KeyboardGestureArea"
+  }
+}

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

@@ -0,0 +1,192 @@
+package com.reactnativekeyboardcontroller.views
+
+import android.annotation.SuppressLint
+import android.graphics.Rect
+import android.os.Build
+import android.view.MotionEvent
+import android.view.VelocityTracker
+import android.view.ViewConfiguration
+import androidx.annotation.RequiresApi
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.views.view.ReactViewGroup
+import com.reactnativekeyboardcontroller.KeyboardAnimationController
+import com.reactnativekeyboardcontroller.extensions.copyBoundsInWindow
+import com.reactnativekeyboardcontroller.interpolators.Interpolator
+import com.reactnativekeyboardcontroller.interpolators.IosInterpolator
+import com.reactnativekeyboardcontroller.interpolators.LinearInterpolator
+import kotlin.math.absoluteValue
+import kotlin.math.roundToInt
+
+val interpolators = mapOf(
+  "linear" to LinearInterpolator(),
+  "ios" to IosInterpolator(),
+)
+
+@SuppressLint("ViewConstructor")
+class KeyboardGestureAreaReactViewGroup(private val reactContext: ThemedReactContext) : ReactViewGroup(reactContext) {
+  // internal state management
+  private var isHandling = false
+  private var lastTouchX = 0f
+  private var lastTouchY = 0f
+  private var lastWindowY = 0
+
+  // react props
+  private var interpolator: Interpolator = LinearInterpolator()
+  private var scrollKeyboardOnScreenWhenNotVisible = false
+  private var scrollKeyboardOffScreenWhenVisible = true
+
+  private val bounds = Rect()
+
+  private val controller = KeyboardAnimationController()
+
+  private var velocityTracker: VelocityTracker? = null
+
+  @RequiresApi(Build.VERSION_CODES.R)
+  override fun dispatchTouchEvent(event: MotionEvent?): Boolean {
+    if (velocityTracker == null) {
+      // Obtain a VelocityTracker if we don't have one yet
+      velocityTracker = VelocityTracker.obtain()
+    }
+
+    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()
+      }
+    }
+
+    return super.dispatchTouchEvent(event)
+  }
+
+  fun setInterpolator(interpolator: String) {
+    this.interpolator = interpolators[interpolator] ?: LinearInterpolator()
+  }
+
+  fun setScrollKeyboardOnScreenWhenNotVisible(scrollImeOnScreenWhenNotVisible: Boolean) {
+    this.scrollKeyboardOnScreenWhenNotVisible = scrollImeOnScreenWhenNotVisible
+  }
+
+  fun setScrollKeyboardOffScreenWhenVisible(scrollImeOffScreenWhenVisible: Boolean) {
+    this.scrollKeyboardOffScreenWhenVisible = scrollImeOffScreenWhenVisible
+  }
+
+  /**
+   * Resets all of our internal state.
+   */
+  private fun reset() {
+    // Clear all of our internal state
+    isHandling = false
+    lastTouchX = 0f
+    lastTouchY = 0f
+    lastWindowY = 0
+    bounds.setEmpty()
+
+    velocityTracker?.recycle()
+    velocityTracker = null
+  }
+
+  /**
+   * Returns true if the given [dy], [IME visibility][imeVisible], and constructor options
+   * support a IME animation request.
+   */
+  private fun shouldStartRequest(dy: Float, imeVisible: Boolean) = when {
+    // If the user is scroll up, return true if scrollImeOnScreenWhenNotVisible is true, and
+    // the IME is not currently visible
+    dy < 0 -> !imeVisible && scrollKeyboardOnScreenWhenNotVisible
+    // If the user is scroll down, start the request if scrollImeOffScreenWhenVisible is true,
+    // and the IME is currently visible
+    dy > 0 -> imeVisible && scrollKeyboardOffScreenWhenVisible
+    // Otherwise, return false
+    else -> false
+  }
+
+  @RequiresApi(Build.VERSION_CODES.R)
+  private fun getWindowHeight(): Int {
+    val metrics = reactContext.currentActivity?.windowManager?.currentWindowMetrics
+
+    return metrics?.bounds?.height() ?: 0
+  }
+}

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

@@ -0,0 +1,33 @@
+package com.reactnativekeyboardcontroller
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.views.view.ReactViewManager
+import com.reactnativekeyboardcontroller.managers.KeyboardGestureAreaViewManagerImpl
+import com.reactnativekeyboardcontroller.views.KeyboardGestureAreaReactViewGroup
+
+class KeyboardGestureAreaViewManager(mReactContext: ReactApplicationContext) : ReactViewManager() {
+  private val manager = KeyboardGestureAreaViewManagerImpl(mReactContext)
+
+  override fun getName(): String = KeyboardGestureAreaViewManagerImpl.NAME
+
+  override fun createViewInstance(reactContext: ThemedReactContext): KeyboardGestureAreaReactViewGroup {
+    return manager.createViewInstance(reactContext)
+  }
+
+  @ReactProp(name = "interpolator")
+  fun setInterpolator(view: KeyboardGestureAreaReactViewGroup, interpolator: String) {
+    manager.setInterpolator(view, interpolator)
+  }
+
+  @ReactProp(name = "showOnSwipeUp")
+  fun setScrollKeyboardOnScreenWhenNotVisible(view: KeyboardGestureAreaReactViewGroup, value: Boolean) {
+    manager.setScrollKeyboardOnScreenWhenNotVisible(view, value)
+  }
+
+  @ReactProp(name = "enableSwipeToDismiss")
+  fun setScrollKeyboardOffScreenWhenVisible(view: KeyboardGestureAreaReactViewGroup, value: Boolean) {
+    manager.setScrollKeyboardOffScreenWhenVisible(view, value)
+  }
+}

package/ios/KeyboardControllerView.mm

@@ -52,23 +52,30 @@ using namespace facebook::react;
                   self->_eventEmitter)
                   ->onKeyboardMoveStart(
                       facebook::react::KeyboardControllerViewEventEmitter::OnKeyboardMoveStart{
-                          .height = [height intValue], .progress = [progress floatValue]});
+                          .height = [height doubleValue], .progress = [progress doubleValue]});
             }
             if ([event isEqualToString:@"onKeyboardMove"]) {
               std::dynamic_pointer_cast<const facebook::react::KeyboardControllerViewEventEmitter>(
                   self->_eventEmitter)
                   ->onKeyboardMove(
                       facebook::react::KeyboardControllerViewEventEmitter::OnKeyboardMove{
-                          .height = [height intValue], .progress = [progress floatValue]});
+                          .height = [height doubleValue], .progress = [progress doubleValue]});
             }
             if ([event isEqualToString:@"onKeyboardMoveEnd"]) {
               std::dynamic_pointer_cast<const facebook::react::KeyboardControllerViewEventEmitter>(
                   self->_eventEmitter)
                   ->onKeyboardMoveEnd(
                       facebook::react::KeyboardControllerViewEventEmitter::OnKeyboardMoveEnd{
-                          .height = [height intValue], .progress = [progress floatValue]});
+                          .height = [height doubleValue], .progress = [progress doubleValue]});
             }
           }
+          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]});
+          }
 
           // TODO: use built-in _eventEmitter once NativeAnimated module will use ModernEventemitter
           RCTBridge *bridge = [RCTBridge currentBridge];

package/ios/KeyboardControllerViewManager.mm

@@ -5,5 +5,6 @@
 RCT_EXPORT_VIEW_PROPERTY(onKeyboardMoveStart, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onKeyboardMove, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onKeyboardMoveEnd, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onKeyboardMoveInteractive, RCTDirectEventBlock);
 
 @end

package/ios/KeyboardControllerViewManager.swift

@@ -15,6 +15,7 @@ class KeyboardControllerView: UIView {
   @objc var onKeyboardMoveStart: RCTDirectEventBlock?
   @objc var onKeyboardMove: RCTDirectEventBlock?
   @objc var onKeyboardMoveEnd: RCTDirectEventBlock?
+  @objc var onKeyboardMoveInteractive: RCTDirectEventBlock?
 
   init(frame: CGRect, eventDispatcher: RCTEventDispatcherProtocol) {
     self.eventDispatcher = eventDispatcher

package/ios/KeyboardMovementObserver.swift

@@ -8,6 +8,18 @@
 
 import Foundation
 
+func interpolate(inputRange: [CGFloat], outputRange: [CGFloat], currentValue: CGFloat) -> CGFloat {
+  let inputMin = inputRange.min() ?? 0
+  let inputMax = inputRange.max() ?? 1
+  let outputMin = outputRange.min() ?? 0
+  let outputMax = outputRange.max() ?? 1
+
+  let normalizedValue = (currentValue - inputMin) / (inputMax - inputMin)
+  let interpolatedValue = outputMin + (outputMax - outputMin) * normalizedValue
+
+  return interpolatedValue
+}
+
 @objc(KeyboardMovementObserver)
 public class KeyboardMovementObserver: NSObject {
   // class members
@@ -64,10 +76,63 @@ public class KeyboardMovementObserver: NSObject {
       name: UIResponder.keyboardDidHideNotification,
       object: nil
     )
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(windowDidBecomeVisible),
+      name: UIWindow.didBecomeVisibleNotification,
+      object: nil
+    )
+  }
+
+  @objc func windowDidBecomeVisible(_: Notification) {
+    let keyboardView = findKeyboardView()
+
+    if keyboardView == _keyboardView {
+      return
+    }
+
+    _keyboardView = keyboardView
+
+    keyboardView?.addObserver(self, forKeyPath: "center", options: .new, context: nil)
+  }
+
+  // swiftlint:disable:next block_based_kvo
+  @objc override public func observeValue(
+    forKeyPath keyPath: String?,
+    of object: Any?,
+    change: [NSKeyValueChangeKey: Any]?,
+    context _: UnsafeMutableRawPointer?
+  ) {
+    // swiftlint:disable:next force_cast
+    if keyPath == "center", object as! NSObject == _keyboardView! {
+      // if we are currently animating keyboard or keyboard is not shown yet -> we need to ignore values from KVO
+      if displayLink != nil || keyboardHeight == 0.0 {
+        return
+      }
+
+      // swiftlint:disable:next force_cast
+      let keyboardFrameY = (change?[.newKey] as! NSValue).cgPointValue.y
+      let keyboardWindowH = keyboardView?.window?.bounds.size.height ?? 0
+      let keyboardPosition = keyboardWindowH - keyboardFrameY
+      let position = 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
+      }
+
+      onEvent("onKeyboardMoveInteractive", position as NSNumber, position / CGFloat(keyboardHeight) as NSNumber)
+    }
   }
 
   @objc public func unmount() {
-    // swiftlint:disable notification_center_detachment
+    // swiftlint:disable:next notification_center_detachment
     NotificationCenter.default.removeObserver(self)
   }
 
@@ -115,6 +180,8 @@ public class KeyboardMovementObserver: NSObject {
     var data = [AnyHashable: Any]()
     data["height"] = 0
 
+    keyboardHeight = 0.0
+
     onEvent("onKeyboardMoveEnd", 0 as NSNumber, 0)
     onNotify("KeyboardController::keyboardDidHide", data)
 
@@ -122,6 +189,13 @@ public class KeyboardMovementObserver: NSObject {
   }
 
   @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 != nil {
+      return
+    }
+
     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)
@@ -161,9 +235,9 @@ public class KeyboardMovementObserver: NSObject {
       return
     }
 
-    var keyboardFrameY = keyboardView?.layer.presentation()?.frame.origin.y ?? 0
-    var keyboardWindowH = keyboardView?.window?.bounds.size.height ?? 0
-    var keyboardPosition = keyboardWindowH - keyboardFrameY
+    let keyboardFrameY = keyboardView?.layer.presentation()?.frame.origin.y ?? 0
+    let keyboardWindowH = keyboardView?.window?.bounds.size.height ?? 0
+    let keyboardPosition = keyboardWindowH - keyboardFrameY
 
     if keyboardPosition == prevKeyboardPosition || keyboardFrameY == 0 {
       return

package/jest/index.js

@@ -28,6 +28,7 @@ const mock = {
   },
   // views
   KeyboardControllerView: 'KeyboardControllerView',
+  KeyboardGestureArea: 'KeyboardGestureArea',
   // providers
   KeyboardProvider: 'KeyboardProvider',
 };

package/lib/commonjs/animated.js

@@ -4,25 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.KeyboardProvider = void 0;
-
 var _react = _interopRequireWildcard(require("react"));
-
 var _reactNative = require("react-native");
-
 var _reactNativeReanimated = _interopRequireWildcard(require("react-native-reanimated"));
-
 var _context = require("./context");
-
 var _internal = require("./internal");
-
 var _native = require("./native");
-
 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 styles = _reactNative.StyleSheet.create({
   container: {
     flex: 1
@@ -32,7 +22,6 @@ const styles = _reactNative.StyleSheet.create({
     position: 'absolute'
   }
 });
-
 const KeyboardProvider = _ref => {
   let {
     children,
@@ -41,15 +30,15 @@ const KeyboardProvider = _ref => {
   } = _ref;
   // animated values
   const progress = (0, _internal.useAnimatedValue)(0);
-  const height = (0, _internal.useAnimatedValue)(0); // shared values
-
+  const height = (0, _internal.useAnimatedValue)(0);
+  // shared values
   const progressSV = (0, _reactNativeReanimated.useSharedValue)(0);
   const heightSV = (0, _reactNativeReanimated.useSharedValue)(0);
   const {
     setHandlers,
     broadcast
-  } = (0, _internal.useSharedHandlers)(); // memo
-
+  } = (0, _internal.useSharedHandlers)();
+  // memo
   const context = (0, _react.useMemo)(() => ({
     animated: {
       progress: progress,
@@ -75,8 +64,8 @@ const KeyboardProvider = _ref => {
     }
   }], {
     useNativeDriver: true
-  }), []); // handlers
-
+  }), []);
+  // handlers
   const updateSharedValues = (event, platforms) => {
     'worklet';
 
@@ -85,7 +74,6 @@ const KeyboardProvider = _ref => {
       heightSV.value = -event.height;
     }
   };
-
   const handler = (0, _internal.useAnimatedKeyboardHandler)({
     onKeyboardMoveStart: event => {
       'worklet';
@@ -103,6 +91,12 @@ const KeyboardProvider = _ref => {
       'worklet';
 
       broadcast('onEnd', event);
+    },
+    onKeyboardMoveInteractive: event => {
+      'worklet';
+
+      updateSharedValues(event, ['android', 'ios']);
+      broadcast('onInteractive', event);
     }
   }, []);
   return /*#__PURE__*/_react.default.createElement(_context.KeyboardContext.Provider, {
@@ -111,6 +105,7 @@ const KeyboardProvider = _ref => {
     onKeyboardMoveReanimated: handler,
     onKeyboardMoveStart: _reactNative.Platform.OS === 'ios' ? onKeyboardMove : undefined,
     onKeyboardMove: _reactNative.Platform.OS === 'android' ? onKeyboardMove : undefined,
+    onKeyboardMoveInteractive: onKeyboardMove,
     navigationBarTranslucent: navigationBarTranslucent,
     statusBarTranslucent: statusBarTranslucent,
     style: styles.container
@@ -126,6 +121,5 @@ const KeyboardProvider = _ref => {
     style: style
   }), children)));
 };
-
 exports.KeyboardProvider = KeyboardProvider;
 //# sourceMappingURL=animated.js.map