react-native-keyboard-controller 1.4.4 → 1.5.1

package/README.md

@@ -12,7 +12,7 @@ Keyboard manager which works in identical way on both iOS and Android.
 - missing `keyboardWillShow` / `keyboardWillHide` events are available on Android 😍
 - module for changing soft input mode on Android 🤔
 - reanimated support 🚀
-- interactive keyboard dismissing (planned) 👆📱
+- interactive keyboard dismissing 👆📱
 - and more is coming... Stay tuned! 😊
 
 ## Installation

package/android/build.gradle

@@ -33,6 +33,7 @@ def reactNativeArchitectures() {
 
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
+apply from: "$projectDir/react-native-helpers.gradle"
 
 if (isNewArchitectureEnabled()) {
   apply plugin: 'com.facebook.react'
@@ -151,8 +152,14 @@ repositories {
 def kotlin_version = getExtOrDefault('kotlinVersion')
 
 dependencies {
-  // noinspection GradleDynamicVersion
-  api 'com.facebook.react:react-native:+'
+  if (project.ext.shouldConsumeReactNativeFromMavenCentral()) {
+    // noinspection GradleDynamicVersion
+    implementation 'com.facebook.react:react-android:+'
+  } else {
+    // noinspection GradleDynamicVersion
+    implementation 'com.facebook.react:react-native:+'
+  }
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation 'androidx.core:core-ktx:1.5.0-beta03'
+  implementation 'androidx.dynamicanimation:dynamicanimation-ktx:1.0.0-alpha03'
 }

package/android/gradle.properties

@@ -1,5 +1,5 @@
 KeyboardController_kotlinVersion=1.6.21
-KeyboardController_compileSdkVersion=29
-KeyboardController_targetSdkVersion=29
+KeyboardController_compileSdkVersion=33
+KeyboardController_targetSdkVersion=33
 
 android.useAndroidX=true

package/android/react-native-helpers.gradle

@@ -0,0 +1,48 @@
+def safeAppExtGet(prop, fallback) {
+  def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+  appProject?.ext?.has(prop) ? appProject.ext.get(prop) : fallback
+}
+
+// Let's detect react-native's directory, it will be used to determine RN's version
+// https://github.com/software-mansion/react-native-reanimated/blob/cda4627c3337c33674f05f755b7485165c6caca9/android/build.gradle#L88
+def resolveReactNativeDirectory() {
+  def reactNativeLocation = safeAppExtGet("REACT_NATIVE_NODE_MODULES_DIR", null)
+  if (reactNativeLocation != null) {
+    return file(reactNativeLocation)
+  }
+
+  // monorepo workaround
+  // react-native can be hoisted or in project's own node_modules
+  def reactNativeFromProjectNodeModules = file("${rootProject.projectDir}/../node_modules/react-native")
+  if (reactNativeFromProjectNodeModules.exists()) {
+    return reactNativeFromProjectNodeModules
+  }
+
+  def reactNativeFromNodeModules = file("${projectDir}/../../react-native")
+  if (reactNativeFromNodeModules.exists()) {
+    return reactNativeFromNodeModules
+  }
+
+  throw new GradleException(
+    "${project.name}: unable to resolve react-native location in " +
+    "node_modules. You should project extension property (in app/build.gradle) " +
+    "`REACT_NATIVE_NODE_MODULES_DIR` with path to react-native."
+  )
+}
+
+// https://github.com/software-mansion/react-native-reanimated/blob/cda4627c3337c33674f05f755b7485165c6caca9/android/build.gradle#L199#L205
+def reactNativeRootDir = resolveReactNativeDirectory()
+
+def reactProperties = new Properties()
+file("$reactNativeRootDir/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
+
+def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME")
+def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.startsWith("0.0.0-") ? 1000 : REACT_NATIVE_VERSION.split("\\.")[1].toInteger()
+
+project.ext.resolveReactNativeDirectory = { ->
+  return resolveReactNativeDirectory()
+}
+
+project.ext.shouldConsumeReactNativeFromMavenCentral = { ->
+  return REACT_NATIVE_MINOR_VERSION >= 71
+}

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

@@ -0,0 +1,44 @@
+package com.reactnativekeyboardcontroller
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.KeyboardGestureAreaManagerDelegate
+import com.facebook.react.viewmanagers.KeyboardGestureAreaManagerInterface
+import com.facebook.react.views.view.ReactViewGroup
+import com.facebook.react.views.view.ReactViewManager
+import com.reactnativekeyboardcontroller.managers.KeyboardGestureAreaViewManagerImpl
+import com.reactnativekeyboardcontroller.views.KeyboardGestureAreaReactViewGroup
+
+class KeyboardGestureAreaViewManager(mReactContext: ReactApplicationContext) :
+  ReactViewManager(),
+  KeyboardGestureAreaManagerInterface<ReactViewGroup> {
+  private val manager = KeyboardGestureAreaViewManagerImpl(mReactContext)
+  private val mDelegate = KeyboardGestureAreaManagerDelegate(this)
+
+  override fun getDelegate(): ViewManagerDelegate<ReactViewGroup?> {
+    return mDelegate
+  }
+
+  override fun getName(): String = KeyboardGestureAreaViewManagerImpl.NAME
+
+  override fun createViewInstance(context: ThemedReactContext): KeyboardGestureAreaReactViewGroup {
+    return manager.createViewInstance(context)
+  }
+
+  @ReactProp(name = "interpolator")
+  override fun setInterpolator(view: ReactViewGroup, value: String?) {
+    manager.setInterpolator(view as KeyboardGestureAreaReactViewGroup, value ?: "linear")
+  }
+
+  @ReactProp(name = "showOnSwipeUp")
+  override fun setShowOnSwipeUp(view: ReactViewGroup, value: Boolean) {
+    manager.setScrollKeyboardOnScreenWhenNotVisible(view as KeyboardGestureAreaReactViewGroup, value)
+  }
+
+  @ReactProp(name = "enableSwipeToDismiss")
+  override fun setEnableSwipeToDismiss(view: ReactViewGroup?, value: Boolean) {
+    manager.setScrollKeyboardOffScreenWhenVisible(view as KeyboardGestureAreaReactViewGroup, value)
+  }
+}

package/android/src/main/java/com/reactnativekeyboardcontroller/InteractiveKeyboardProvider.kt

@@ -0,0 +1,6 @@
+package com.reactnativekeyboardcontroller
+
+object InteractiveKeyboardProvider {
+  var shown = false
+  var isInteractive = false
+}

package/android/src/main/java/com/reactnativekeyboardcontroller/KeyboardAnimationCallback.kt

@@ -20,6 +20,7 @@ import com.facebook.react.uimanager.events.EventDispatcher
 import com.facebook.react.views.view.ReactViewGroup
 import com.reactnativekeyboardcontroller.events.KeyboardTransitionEvent
 import com.reactnativekeyboardcontroller.extensions.dp
+import kotlin.math.abs
 
 class KeyboardAnimationCallback(
   val view: ReactViewGroup,
@@ -30,7 +31,7 @@ class KeyboardAnimationCallback(
   val onApplyWindowInsetsListener: OnApplyWindowInsetsListener,
 ) : WindowInsetsAnimationCompat.Callback(dispatchMode), OnApplyWindowInsetsListener {
   private val TAG = KeyboardAnimationCallback::class.qualifiedName
-  private var persistentKeyboardHeight = 0
+  private var persistentKeyboardHeight = 0.0
   private var isKeyboardVisible = false
   private var isTransitioning = false
 
@@ -62,16 +63,16 @@ class KeyboardAnimationCallback(
     // having such check allows us not to dispatch unnecessary incorrect events
     // the condition will be executed only when keyboard is opened and changes its size
     // (for example it happens when user changes keyboard type from 'text' to 'emoji' input
-    if (isKeyboardVisible && isKeyboardVisible() && !isTransitioning && Build.VERSION.SDK_INT >= 30) {
+    if (isKeyboardVisible && isKeyboardVisible() && !isTransitioning && Build.VERSION.SDK_INT >= 30 && !InteractiveKeyboardProvider.isInteractive) {
       val keyboardHeight = getCurrentKeyboardHeight()
 
       this.emitEvent("KeyboardController::keyboardWillShow", getEventParams(keyboardHeight))
       this.sendEventToJS(KeyboardTransitionEvent(view.id, "topKeyboardMoveStart", keyboardHeight, 1.0))
 
-      val animation = ValueAnimator.ofInt(this.persistentKeyboardHeight, keyboardHeight)
+      val animation = ValueAnimator.ofFloat(this.persistentKeyboardHeight.toFloat(), keyboardHeight.toFloat())
       animation.addUpdateListener { animator ->
-        val toValue = animator.animatedValue as Int
-        this.sendEventToJS(KeyboardTransitionEvent(view.id, "topKeyboardMove", toValue, toValue.toDouble() / keyboardHeight))
+        val toValue = animator.animatedValue as Float
+        this.sendEventToJS(KeyboardTransitionEvent(view.id, "topKeyboardMove", toValue.toDouble(), toValue.toDouble() / keyboardHeight))
       }
       animation.doOnEnd {
         this.emitEvent("KeyboardController::keyboardDidShow", getEventParams(keyboardHeight))
@@ -128,13 +129,14 @@ class KeyboardAnimationCallback(
 
     var progress = 0.0
     try {
-      progress = Math.abs((height.toDouble() / persistentKeyboardHeight)).let { if (it.isNaN()) 0.0 else it }
+      progress = abs((height / persistentKeyboardHeight)).let { if (it.isNaN()) 0.0 else it }
     } catch (e: ArithmeticException) {
       // do nothing, send progress as 0
     }
-    Log.i(TAG, "DiffY: $diffY $height $progress")
+    Log.i(TAG, "DiffY: $diffY $height $progress ${InteractiveKeyboardProvider.isInteractive}")
 
-    this.sendEventToJS(KeyboardTransitionEvent(view.id, "topKeyboardMove", height, progress))
+    val event = if (InteractiveKeyboardProvider.isInteractive) "topKeyboardMoveInteractive" else "topKeyboardMove"
+    this.sendEventToJS(KeyboardTransitionEvent(view.id, event, height, progress))
 
     return insets
   }
@@ -143,7 +145,19 @@ class KeyboardAnimationCallback(
     super.onEnd(animation)
 
     isTransitioning = false
-    this.persistentKeyboardHeight = getCurrentKeyboardHeight()
+    // if keyboard becomes shown after interactive animation completion
+    // getCurrentKeyboardHeight() will be `0` and isKeyboardVisible will be `false`
+    // it's not correct behavior, so we are handling it here
+    val isKeyboardShown = InteractiveKeyboardProvider.shown
+    if (!isKeyboardShown) {
+      this.persistentKeyboardHeight = getCurrentKeyboardHeight()
+    } else {
+      // if keyboard is shown after interactions and the animation has finished
+      // then we need to reset the state
+      InteractiveKeyboardProvider.shown = false
+    }
+    val isKeyboardVisible = isKeyboardVisible || isKeyboardShown
+
     this.emitEvent("KeyboardController::" + if (!isKeyboardVisible) "keyboardDidHide" else "keyboardDidShow", getEventParams(this.persistentKeyboardHeight))
     this.sendEventToJS(KeyboardTransitionEvent(view.id, "topKeyboardMoveEnd", this.persistentKeyboardHeight, if (!isKeyboardVisible) 0.0 else 1.0))
   }
@@ -154,13 +168,13 @@ class KeyboardAnimationCallback(
     return insets?.isVisible(WindowInsetsCompat.Type.ime()) ?: false
   }
 
-  private fun getCurrentKeyboardHeight(): Int {
+  private fun getCurrentKeyboardHeight(): Double {
     val insets = ViewCompat.getRootWindowInsets(view)
     val keyboardHeight = insets?.getInsets(WindowInsetsCompat.Type.ime())?.bottom ?: 0
     val navigationBar = insets?.getInsets(WindowInsetsCompat.Type.navigationBars())?.bottom ?: 0
 
     // on hide it will be negative value, so we are using max function
-    return Math.max((keyboardHeight - navigationBar).toFloat().dp, 0)
+    return (keyboardHeight - navigationBar).toFloat().dp.coerceAtLeast(0.0)
   }
 
   private fun sendEventToJS(event: Event<*>) {
@@ -175,9 +189,9 @@ class KeyboardAnimationCallback(
     Log.i(TAG, event)
   }
 
-  private fun getEventParams(height: Int): WritableMap {
+  private fun getEventParams(height: Double): WritableMap {
     val params: WritableMap = Arguments.createMap()
-    params.putInt("height", height)
+    params.putDouble("height", height)
 
     return params
   }

package/android/src/main/java/com/reactnativekeyboardcontroller/KeyboardAnimationController.kt

@@ -0,0 +1,394 @@
+package com.reactnativekeyboardcontroller
+
+import android.os.CancellationSignal
+import android.view.View
+import android.view.animation.LinearInterpolator
+import androidx.core.graphics.Insets
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsAnimationControlListenerCompat
+import androidx.core.view.WindowInsetsAnimationControllerCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.dynamicanimation.animation.SpringAnimation
+import androidx.dynamicanimation.animation.SpringForce
+import androidx.dynamicanimation.animation.springAnimationOf
+import androidx.dynamicanimation.animation.withSpringForceProperties
+import kotlin.math.roundToInt
+
+internal class KeyboardAnimationController {
+  private var insetsAnimationController: WindowInsetsAnimationControllerCompat? = null
+  private var pendingRequestCancellationSignal: CancellationSignal? = null
+  private var pendingRequestOnReady: ((WindowInsetsAnimationControllerCompat) -> Unit)? = null
+
+  /* To take control of the an WindowInsetsAnimation, we need to pass in a listener to
+     controlWindowInsetsAnimation() in startControlRequest(). The listener created here
+     keeps track of the current WindowInsetsAnimationController and resets our state. */
+  private val animationControlListener by lazy {
+    object : WindowInsetsAnimationControlListenerCompat {
+      /**
+       * Once the request is ready, call our [onRequestReady] function
+       */
+      override fun onReady(
+        controller: WindowInsetsAnimationControllerCompat,
+        types: Int,
+      ) = onRequestReady(controller)
+
+      /**
+       * If the request is finished, we should reset our internal state
+       */
+      override fun onFinished(controller: WindowInsetsAnimationControllerCompat) {
+        reset()
+      }
+
+      /**
+       * If the request is cancelled, we should reset our internal state
+       */
+      override fun onCancelled(controller: WindowInsetsAnimationControllerCompat?) {
+        reset()
+      }
+    }
+  }
+
+  /**
+   * True if the IME was shown at the start of the current animation.
+   */
+  private var isImeShownAtStart = false
+
+  private var currentSpringAnimation: SpringAnimation? = null
+
+  /**
+   * Start a control request to the [view]s [android.view.WindowInsetsController]. This should
+   * be called once the view is in a position to take control over the position of the IME.
+   *
+   * @param view The view which is triggering this request
+   * @param onRequestReady optional listener which will be called when the request is ready and
+   * the animation can proceed
+   */
+  fun startControlRequest(
+    view: View,
+    onRequestReady: ((WindowInsetsAnimationControllerCompat) -> Unit)? = null,
+  ) {
+    check(!isInsetAnimationInProgress()) {
+      "Animation in progress. Can not start a new request to controlWindowInsetsAnimation()"
+    }
+
+    // Keep track of the IME insets, and the IME visibility, at the start of the request
+    isImeShownAtStart = ViewCompat.getRootWindowInsets(view)
+      ?.isVisible(WindowInsetsCompat.Type.ime()) == true
+
+    // Create a cancellation signal, which we pass to controlWindowInsetsAnimation() below
+    pendingRequestCancellationSignal = CancellationSignal()
+    // Keep reference to the onReady callback
+    pendingRequestOnReady = onRequestReady
+
+    // update our state manager
+    InteractiveKeyboardProvider.isInteractive = true
+
+    // Finally we make a controlWindowInsetsAnimation() request:
+    ViewCompat.getWindowInsetsController(view)?.controlWindowInsetsAnimation(
+      // We're only catering for IME animations in this listener
+      WindowInsetsCompat.Type.ime(),
+      // Animation duration. This is not used by the system, and is only passed to any
+      // WindowInsetsAnimation.Callback set on views. We pass in -1 to indicate that we're
+      // not starting a finite animation, and that this is completely controlled by
+      // the user's touch.
+      -1,
+      // The time interpolator used in calculating the animation progress. The fraction value
+      // we passed into setInsetsAndAlpha() which be passed into this interpolator before
+      // being used by the system to inset the IME. LinearInterpolator is a good type
+      // to use for scrolling gestures.
+      linearInterpolator,
+      // A cancellation signal, which allows us to cancel the request to control
+      pendingRequestCancellationSignal,
+      // The WindowInsetsAnimationControlListener
+      animationControlListener,
+    )
+  }
+
+  /**
+   * Start a control request to the [view]s [android.view.WindowInsetsController], similar to
+   * [startControlRequest], but immediately fling to a finish using [velocityY] once ready.
+   *
+   * This function is useful for fire-and-forget operations to animate the IME.
+   *
+   * @param view The view which is triggering this request
+   * @param velocityY the velocity of the touch gesture which caused this call
+   */
+  fun startAndFling(view: View, velocityY: Float) = startControlRequest(view) {
+    animateToFinish(velocityY)
+  }
+
+  /**
+   * Update the inset position of the IME by the given [dy] value. This value will be coerced
+   * into the hidden and shown inset values.
+   *
+   * This function should only be called if [isInsetAnimationInProgress] returns true.
+   *
+   * @return the amount of [dy] consumed by the inset animation, in pixels
+   */
+  fun insetBy(dy: Int): Int {
+    val controller = insetsAnimationController
+      ?: throw IllegalStateException(
+        "Current WindowInsetsAnimationController is null." +
+          "This should only be called if isAnimationInProgress() returns true",
+      )
+
+    InteractiveKeyboardProvider.isInteractive = true
+    // Call updateInsetTo() with the new inset value
+    return insetTo(controller.currentInsets.bottom - dy)
+  }
+
+  /**
+   * Update the inset position of the IME to be the given [inset] value. This value will be
+   * coerced into the hidden and shown inset values.
+   *
+   * This function should only be called if [isInsetAnimationInProgress] returns true.
+   *
+   * @return the distance moved by the inset animation, in pixels
+   */
+  fun insetTo(inset: Int): Int {
+    val controller = insetsAnimationController
+      ?: throw IllegalStateException(
+        "Current WindowInsetsAnimationController is null." +
+          "This should only be called if isAnimationInProgress() returns true",
+      )
+
+    val hiddenBottom = controller.hiddenStateInsets.bottom
+    val shownBottom = controller.shownStateInsets.bottom
+    val startBottom = if (isImeShownAtStart) shownBottom else hiddenBottom
+    val endBottom = if (isImeShownAtStart) hiddenBottom else shownBottom
+
+    // We coerce the given inset within the limits of the hidden and shown insets
+    val coercedBottom = inset.coerceIn(hiddenBottom, shownBottom)
+
+    val consumedDy = controller.currentInsets.bottom - coercedBottom
+
+    // Finally update the insets in the WindowInsetsAnimationController using
+    // setInsetsAndAlpha().
+    controller.setInsetsAndAlpha(
+      // Here we update the animating insets. This is what controls where the IME is displayed.
+      // It is also passed through to views via their WindowInsetsAnimation.Callback.
+      Insets.of(0, 0, 0, coercedBottom),
+      // This controls the alpha value. We don't want to alter the alpha so use 1f
+      1f,
+      // Finally we calculate the animation progress fraction. This value is passed through
+      // to any WindowInsetsAnimation.Callbacks, but it is not used by the system.
+      (coercedBottom - startBottom) / (endBottom - startBottom).toFloat(),
+    )
+
+    return consumedDy
+  }
+
+  /**
+   * Return `true` if an inset animation is in progress.
+   */
+  fun isInsetAnimationInProgress(): Boolean {
+    return insetsAnimationController != null
+  }
+
+  /**
+   * Return `true` if an inset animation is currently finishing.
+   */
+  fun isInsetAnimationFinishing(): Boolean {
+    return currentSpringAnimation != null
+  }
+
+  /**
+   * Return `true` if a request to control an inset animation is in progress.
+   */
+  fun isInsetAnimationRequestPending(): Boolean {
+    return pendingRequestCancellationSignal != null
+  }
+
+  /**
+   * Cancel the current [WindowInsetsAnimationControllerCompat]. We immediately finish
+   * the animation, reverting back to the state at the start of the gesture.
+   */
+  fun cancel() {
+    insetsAnimationController?.finish(isImeShownAtStart)
+    pendingRequestCancellationSignal?.cancel()
+
+    // Cancel the current spring animation
+    currentSpringAnimation?.cancel()
+
+    reset()
+  }
+
+  /**
+   * Finish the current [WindowInsetsAnimationControllerCompat] immediately.
+   */
+  fun finish() {
+    val controller = insetsAnimationController
+
+    if (controller == null) {
+      // If we don't currently have a controller, cancel any pending request and return
+      pendingRequestCancellationSignal?.cancel()
+      return
+    }
+
+    val current = controller.currentInsets.bottom
+    val shown = controller.shownStateInsets.bottom
+    val hidden = controller.hiddenStateInsets.bottom
+
+    when (current) {
+      // The current inset matches either the shown/hidden inset, finish() immediately
+      shown -> {
+        InteractiveKeyboardProvider.shown = true
+        controller.finish(true)
+      }
+      hidden -> {
+        InteractiveKeyboardProvider.shown = false
+        controller.finish(false)
+      }
+      else -> {
+        // Otherwise, we'll look at the current position...
+        if (controller.currentFraction >= SCROLL_THRESHOLD) {
+          // If the IME is past the 'threshold' we snap to the toggled state
+          InteractiveKeyboardProvider.shown = !isImeShownAtStart
+          controller.finish(!isImeShownAtStart)
+        } else {
+          // ...otherwise, we snap back to the original visibility
+          InteractiveKeyboardProvider.shown = isImeShownAtStart
+          controller.finish(isImeShownAtStart)
+        }
+      }
+    }
+  }
+
+  /**
+   * Finish the current [WindowInsetsAnimationControllerCompat]. We finish the animation,
+   * animating to the end state if necessary.
+   *
+   * @param velocityY the velocity of the touch gesture which caused this call to [animateToFinish].
+   * Can be `null` if velocity is not available.
+   */
+  fun animateToFinish(velocityY: Float? = null) {
+    val controller = insetsAnimationController
+
+    if (controller == null) {
+      // If we don't currently have a controller, cancel any pending request and return
+      pendingRequestCancellationSignal?.cancel()
+      return
+    }
+
+    InteractiveKeyboardProvider.isInteractive = false
+
+    val current = controller.currentInsets.bottom
+    val shown = controller.shownStateInsets.bottom
+    val hidden = controller.hiddenStateInsets.bottom
+
+    when {
+      // If we have a velocity, we can use it's direction to determine
+      // the visibility. Upwards == visible
+      velocityY != null -> animateImeToVisibility(
+        visible = velocityY < 0,
+        velocityY = velocityY,
+      )
+      // The current inset matches either the shown/hidden inset, finish() immediately
+      current == shown -> controller.finish(true)
+      current == hidden -> controller.finish(false)
+      else -> {
+        // Otherwise, we'll look at the current position...
+        if (controller.currentFraction >= SCROLL_THRESHOLD) {
+          // If the IME is past the 'threshold' we animate it to the toggled state
+          animateImeToVisibility(!isImeShownAtStart)
+        } else {
+          // ...otherwise, we animate it back to the original visibility
+          animateImeToVisibility(isImeShownAtStart)
+        }
+      }
+    }
+  }
+
+  fun getCurrentKeyboardHeight(): Int {
+    val controller = insetsAnimationController
+      ?: throw IllegalStateException(
+        "Current WindowInsetsAnimationController is null." +
+          "This should only be called if isAnimationInProgress() returns true",
+      )
+
+    return controller.currentInsets.bottom
+  }
+
+  private fun onRequestReady(controller: WindowInsetsAnimationControllerCompat) {
+    // The request is ready, so clear out the pending cancellation signal
+    pendingRequestCancellationSignal = null
+    // Store the current WindowInsetsAnimationController
+    insetsAnimationController = controller
+
+    // Call any pending callback
+    pendingRequestOnReady?.invoke(controller)
+    pendingRequestOnReady = null
+  }
+
+  /**
+   * Resets all of our internal state.
+   */
+  private fun reset() {
+    // Clear all of our internal state
+    insetsAnimationController = null
+    pendingRequestCancellationSignal = null
+
+    isImeShownAtStart = false
+
+    currentSpringAnimation?.cancel()
+    currentSpringAnimation = null
+
+    pendingRequestOnReady = null
+  }
+
+  /**
+   * Animate the IME to a given visibility.
+   *
+   * @param visible `true` to animate the IME to it's fully shown state, `false` to it's
+   * fully hidden state.
+   * @param velocityY the velocity of the touch gesture which caused this call. Can be `null`
+   * if velocity is not available.
+   */
+  private fun animateImeToVisibility(
+    visible: Boolean,
+    velocityY: Float? = null,
+  ) {
+    val controller = insetsAnimationController
+      ?: throw IllegalStateException("Controller should not be null")
+
+    currentSpringAnimation = springAnimationOf(
+      setter = {
+        insetTo(it.roundToInt())
+      },
+      getter = { controller.currentInsets.bottom.toFloat() },
+      finalPosition = when {
+        visible -> controller.shownStateInsets.bottom.toFloat()
+        else -> controller.hiddenStateInsets.bottom.toFloat()
+      },
+    ).withSpringForceProperties {
+      // Tweak the damping value, to remove any bounciness.
+      dampingRatio = SpringForce.DAMPING_RATIO_NO_BOUNCY
+      // The stiffness value controls the strength of the spring animation, which
+      // controls the speed. Medium (the default) is a good value, but feel free to
+      // play around with this value.
+      stiffness = SpringForce.STIFFNESS_MEDIUM
+    }.apply {
+      if (velocityY != null) {
+        setStartVelocity(velocityY)
+      }
+      addEndListener { anim, _, _, _ ->
+        if (anim == currentSpringAnimation) {
+          currentSpringAnimation = null
+        }
+        // Once the animation has ended, finish the controller
+        finish()
+      }
+    }.also { it.start() }
+  }
+}
+
+/**
+ * Scroll threshold for determining whether to animating to the end state, or to the start state.
+ * Currently 15% of the total swipe distance distance
+ */
+private const val SCROLL_THRESHOLD = 0.15f
+
+/**
+ * A LinearInterpolator instance we can re-use across listeners.
+ */
+private val linearInterpolator = LinearInterpolator()

package/android/src/main/java/com/reactnativekeyboardcontroller/KeyboardControllerPackage.kt

@@ -54,6 +54,6 @@ class KeyboardControllerPackage : TurboReactPackage() {
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return listOf(KeyboardControllerViewManager(reactContext))
+    return listOf(KeyboardControllerViewManager(reactContext), KeyboardGestureAreaViewManager(reactContext))
   }
 }

package/android/src/main/java/com/reactnativekeyboardcontroller/events/KeyboardTransitionEvent.kt

@@ -4,7 +4,7 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.uimanager.events.Event
 import com.facebook.react.uimanager.events.RCTEventEmitter
 
-class KeyboardTransitionEvent(viewId: Int, private val event: String, private val height: Int, private val progress: Double) : Event<KeyboardTransitionEvent>(viewId) {
+class KeyboardTransitionEvent(viewId: Int, private val event: String, private val height: Double, private val progress: Double) : Event<KeyboardTransitionEvent>(viewId) {
   override fun getEventName() = event
 
   // TODO: All events for a given view can be coalesced?
@@ -13,7 +13,7 @@ class KeyboardTransitionEvent(viewId: Int, private val event: String, private va
   override fun dispatch(rctEventEmitter: RCTEventEmitter) {
     val map = Arguments.createMap()
     map.putDouble("progress", progress)
-    map.putInt("height", height)
+    map.putDouble("height", height)
     rctEventEmitter.receiveEvent(viewTag, eventName, map)
   }
 }