react-native-keyboard-controller 1.13.4 → 1.14.1

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

@@ -14,14 +14,21 @@ fun ThemedReactContext.setupWindowDimensionsListener() {
   WindowDimensionListener(this)
 }
 
-fun ThemedReactContext?.dispatchEvent(viewId: Int, event: Event<*>) {
+fun ThemedReactContext?.dispatchEvent(
+  viewId: Int,
+  event: Event<*>,
+) {
   val eventDispatcher: EventDispatcher? =
     UIManagerHelper.getEventDispatcherForReactTag(this as ReactContext, viewId)
   eventDispatcher?.dispatchEvent(event)
 }
 
-fun ThemedReactContext?.emitEvent(event: String, params: WritableMap) {
-  this?.reactApplicationContext
+fun ThemedReactContext?.emitEvent(
+  event: String,
+  params: WritableMap,
+) {
+  this
+    ?.reactApplicationContext
     ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
     ?.emit(event, params)
 

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

@@ -18,16 +18,18 @@ fun View.requestApplyInsetsWhenAttached() {
     requestApplyInsets()
   } else {
     // We're not attached to the hierarchy, add a listener to request when we are
-    addOnAttachStateChangeListener(object : View.OnAttachStateChangeListener {
-      override fun onViewAttachedToWindow(v: View) {
-        v.removeOnAttachStateChangeListener(this)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH) {
-          v.requestApplyInsets()
+    addOnAttachStateChangeListener(
+      object : View.OnAttachStateChangeListener {
+        override fun onViewAttachedToWindow(v: View) {
+          v.removeOnAttachStateChangeListener(this)
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH) {
+            v.requestApplyInsets()
+          }
         }
-      }
 
-      override fun onViewDetachedFromWindow(v: View) = Unit
-    })
+        override fun onViewDetachedFromWindow(v: View) = Unit
+      },
+    )
   }
 }
 

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

@@ -73,7 +73,8 @@ internal class KeyboardAnimationController {
     }
 
     // Keep track of the IME insets, and the IME visibility, at the start of the request
-    isImeShownAtStart = ViewCompat.getRootWindowInsets(view)
+    isImeShownAtStart = ViewCompat
+      .getRootWindowInsets(view)
       ?.isVisible(WindowInsetsCompat.Type.ime()) == true
 
     // Create a cancellation signal, which we pass to controlWindowInsetsAnimation() below
@@ -114,7 +115,10 @@ internal class KeyboardAnimationController {
    * @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) {
+  fun startAndFling(
+    view: View,
+    velocityY: Float,
+  ) = startControlRequest(view) {
     animateToFinish(velocityY)
   }
 
@@ -127,11 +131,12 @@ internal class KeyboardAnimationController {
    * @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",
-      )
+    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
@@ -147,11 +152,12 @@ internal class KeyboardAnimationController {
    * @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 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
@@ -182,23 +188,17 @@ internal class KeyboardAnimationController {
   /**
    * Return `true` if an inset animation is in progress.
    */
-  fun isInsetAnimationInProgress(): Boolean {
-    return insetsAnimationController != null
-  }
+  fun isInsetAnimationInProgress(): Boolean = insetsAnimationController != null
 
   /**
    * Return `true` if an inset animation is currently finishing.
    */
-  fun isInsetAnimationFinishing(): Boolean {
-    return currentSpringAnimation != null
-  }
+  fun isInsetAnimationFinishing(): Boolean = currentSpringAnimation != null
 
   /**
    * Return `true` if a request to control an inset animation is in progress.
    */
-  fun isInsetAnimationRequestPending(): Boolean {
-    return pendingRequestCancellationSignal != null
-  }
+  fun isInsetAnimationRequestPending(): Boolean = pendingRequestCancellationSignal != null
 
   /**
    * Cancel the current [WindowInsetsAnimationControllerCompat]. We immediately finish
@@ -280,10 +280,11 @@ internal class KeyboardAnimationController {
     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,
-      )
+      velocityY != null ->
+        animateImeToVisibility(
+          visible = velocityY < 0,
+          velocityY = velocityY,
+        )
       // The current inset matches either the shown/hidden inset, finish() immediately
       current == shown -> {
         InteractiveKeyboardProvider.shown = true
@@ -307,11 +308,12 @@ internal class KeyboardAnimationController {
   }
 
   fun getCurrentKeyboardHeight(): Int {
-    val controller = insetsAnimationController
-      ?: throw IllegalStateException(
-        "Current WindowInsetsAnimationController is null." +
-          "This should only be called if isAnimationInProgress() returns true",
-      )
+    val controller =
+      insetsAnimationController
+        ?: throw IllegalStateException(
+          "Current WindowInsetsAnimationController is null." +
+            "This should only be called if isAnimationInProgress() returns true",
+        )
 
     return controller.currentInsets.bottom
   }
@@ -356,37 +358,40 @@ internal class KeyboardAnimationController {
     velocityY: Float? = null,
   ) {
     @Suppress("detekt:UseCheckOrError")
-    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
+    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)
         }
-        // Once the animation has ended, finish the controller
-        finish()
-      }
-    }.also { it.start() }
+        addEndListener { anim, _, _, _ ->
+          if (anim == currentSpringAnimation) {
+            currentSpringAnimation = null
+          }
+          // Once the animation has ended, finish the controller
+          finish()
+        }
+      }.also { it.start() }
   }
 }
 

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

@@ -11,5 +11,10 @@ interface Interpolator {
    * @param offset extra space to the keyboard to activate a gesture
    * @return the distance the keyboard should be moved from its current location.
    */
-  fun interpolate(dy: Int, absoluteFingerPosition: Int, keyboardPosition: Int, offset: Int): Int
+  fun interpolate(
+    dy: Int,
+    absoluteFingerPosition: Int,
+    keyboardPosition: Int,
+    offset: Int,
+  ): Int
 }

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

@@ -8,8 +8,10 @@ class IosInterpolator : Interpolator {
     offset: Int,
   ): Int {
     if (
-      absoluteFingerPosition <= keyboardPosition + offset || // user over scrolled keyboard
-      dy <= 0 // user scrolls up
+      // user over scrolled keyboard
+      absoluteFingerPosition <= keyboardPosition + offset ||
+      // user scrolls up
+      dy <= 0
     ) {
       return dy
     }

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

@@ -6,7 +6,5 @@ class LinearInterpolator : Interpolator {
     absoluteFingerPosition: Int,
     keyboardPosition: Int,
     offset: Int,
-  ): Int {
-    return dy
-  }
+  ): Int = dy
 }

package/android/src/main/java/com/reactnativekeyboardcontroller/listeners/FocusedInputObserver.kt

@@ -25,16 +25,17 @@ import com.reactnativekeyboardcontroller.extensions.screenLocation
 import com.reactnativekeyboardcontroller.traversal.FocusedInputHolder
 import com.reactnativekeyboardcontroller.traversal.ViewHierarchyNavigator
 
-val noFocusedInputEvent = FocusedInputLayoutChangedEventData(
-  x = 0.0,
-  y = 0.0,
-  width = 0.0,
-  height = 0.0,
-  absoluteX = 0.0,
-  absoluteY = 0.0,
-  target = -1,
-  parentScrollViewTarget = -1,
-)
+val noFocusedInputEvent =
+  FocusedInputLayoutChangedEventData(
+    x = 0.0,
+    y = 0.0,
+    width = 0.0,
+    height = 0.0,
+    absoluteX = 0.0,
+    absoluteY = 0.0,
+    target = -1,
+    parentScrollViewTarget = -1,
+  )
 
 class FocusedInputObserver(
   val view: View,
@@ -82,50 +83,52 @@ class FocusedInputObserver(
       FocusedInputSelectionChangedEvent(
         surfaceId,
         eventPropagationView.id,
-        event = FocusedInputSelectionChangedEventData(
-          target = input.id,
-          start = start,
-          end = end,
-          startX = startX,
-          startY = startY,
-          endX = endX,
-          endY = endY,
-        ),
+        event =
+          FocusedInputSelectionChangedEventData(
+            target = input.id,
+            start = start,
+            end = end,
+            startX = startX,
+            startY = startY,
+            endX = endX,
+            endY = endY,
+          ),
       ),
     )
   }
-  private val focusListener = OnGlobalFocusChangeListener { oldFocus, newFocus ->
-    // unfocused or focus was changed
-    if (newFocus == null || oldFocus != null) {
-      lastFocusedInput?.removeOnLayoutChangeListener(layoutListener)
-      lastFocusedInput?.removeTextChangedListener(textWatcher)
-      selectionSubscription?.invoke()
-      lastFocusedInput = null
-    }
-    if (newFocus is ReactEditText) {
-      lastFocusedInput = newFocus
-      newFocus.addOnLayoutChangeListener(layoutListener)
-      this.syncUpLayout()
-      textWatcher = newFocus.addOnTextChangedListener(textListener)
-      selectionSubscription = newFocus.addOnSelectionChangedListener(selectionListener)
-      FocusedInputHolder.set(newFocus)
+  private val focusListener =
+    OnGlobalFocusChangeListener { oldFocus, newFocus ->
+      // unfocused or focus was changed
+      if (newFocus == null || oldFocus != null) {
+        lastFocusedInput?.removeOnLayoutChangeListener(layoutListener)
+        lastFocusedInput?.removeTextChangedListener(textWatcher)
+        selectionSubscription?.invoke()
+        lastFocusedInput = null
+      }
+      if (newFocus is ReactEditText) {
+        lastFocusedInput = newFocus
+        newFocus.addOnLayoutChangeListener(layoutListener)
+        this.syncUpLayout()
+        textWatcher = newFocus.addOnTextChangedListener(textListener)
+        selectionSubscription = newFocus.addOnSelectionChangedListener(selectionListener)
+        FocusedInputHolder.set(newFocus)
 
-      val allInputFields = ViewHierarchyNavigator.getAllInputFields(context?.rootView)
-      val currentIndex = allInputFields.indexOf(newFocus)
+        val allInputFields = ViewHierarchyNavigator.getAllInputFields(context?.rootView)
+        val currentIndex = allInputFields.indexOf(newFocus)
 
-      context.emitEvent(
-        "KeyboardController::focusDidSet",
-        Arguments.createMap().apply {
-          putInt("current", currentIndex)
-          putInt("count", allInputFields.size)
-        },
-      )
+        context.emitEvent(
+          "KeyboardController::focusDidSet",
+          Arguments.createMap().apply {
+            putInt("current", currentIndex)
+            putInt("count", allInputFields.size)
+          },
+        )
+      }
+      // unfocused
+      if (newFocus == null) {
+        dispatchEventToJS(noFocusedInputEvent)
+      }
     }
-    // unfocused
-    if (newFocus == null) {
-      dispatchEventToJS(noFocusedInputEvent)
-    }
-  }
 
   init {
     view.viewTreeObserver.addOnGlobalFocusChangeListener(focusListener)
@@ -135,16 +138,17 @@ class FocusedInputObserver(
     val input = lastFocusedInput ?: return
 
     val (x, y) = input.screenLocation
-    val event = FocusedInputLayoutChangedEventData(
-      x = input.x.dp,
-      y = input.y.dp,
-      width = input.width.toFloat().dp,
-      height = input.height.toFloat().dp,
-      absoluteX = x.toFloat().dp,
-      absoluteY = y.toFloat().dp,
-      target = input.id,
-      parentScrollViewTarget = input.parentScrollViewTarget,
-    )
+    val event =
+      FocusedInputLayoutChangedEventData(
+        x = input.x.dp,
+        y = input.y.dp,
+        width = input.width.toFloat().dp,
+        height = input.height.toFloat().dp,
+        absoluteX = x.toFloat().dp,
+        absoluteY = y.toFloat().dp,
+        target = input.id,
+        parentScrollViewTarget = input.parentScrollViewTarget,
+      )
 
     dispatchEventToJS(event)
   }

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

@@ -1,6 +1,5 @@
 package com.reactnativekeyboardcontroller.listeners
 
-import android.os.Build
 import android.view.View
 import android.view.ViewTreeObserver.OnGlobalFocusChangeListener
 import androidx.core.graphics.Insets
@@ -14,6 +13,7 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.views.textinput.ReactEditText
 import com.facebook.react.views.view.ReactViewGroup
+import com.reactnativekeyboardcontroller.constants.Keyboard
 import com.reactnativekeyboardcontroller.events.KeyboardTransitionEvent
 import com.reactnativekeyboardcontroller.extensions.dispatchEvent
 import com.reactnativekeyboardcontroller.extensions.dp
@@ -24,7 +24,7 @@ import com.reactnativekeyboardcontroller.log.Logger
 import kotlin.math.abs
 
 private val TAG = KeyboardAnimationCallback::class.qualifiedName
-private val isResizeHandledInCallbackMethods = Build.VERSION.SDK_INT < Build.VERSION_CODES.R
+private val isResizeHandledInCallbackMethods = Keyboard.IS_ANIMATION_EMULATED
 
 data class KeyboardAnimationCallbackConfig(
   val persistentInsetTypes: Int,
@@ -33,12 +33,22 @@ data class KeyboardAnimationCallbackConfig(
   val hasTranslucentNavigationBar: Boolean = false,
 )
 
+interface Suspendable {
+  var isSuspended: Boolean
+
+  fun suspend(suspended: Boolean) {
+    isSuspended = suspended
+  }
+}
+
 class KeyboardAnimationCallback(
   val eventPropagationView: ReactViewGroup,
   val view: View,
   val context: ThemedReactContext?,
   private val config: KeyboardAnimationCallbackConfig,
-) : WindowInsetsAnimationCompat.Callback(config.dispatchMode), OnApplyWindowInsetsListener {
+) : WindowInsetsAnimationCompat.Callback(config.dispatchMode),
+  OnApplyWindowInsetsListener,
+  Suspendable {
   private val surfaceId = UIManagerHelper.getSurfaceId(eventPropagationView)
 
   // state variables
@@ -49,48 +59,50 @@ class KeyboardAnimationCallback(
   private var duration = 0
   private var viewTagFocused = -1
   private var animationsToSkip = hashSetOf<WindowInsetsAnimationCompat>()
+  override var isSuspended: Boolean = false
 
   // listeners
-  private val focusListener = OnGlobalFocusChangeListener { oldFocus, newFocus ->
-    if (newFocus is ReactEditText) {
-      viewTagFocused = newFocus.id
-
-      // keyboard is visible and focus has been changed
-      if (this.isKeyboardVisible && oldFocus !== null) {
-        // imitate iOS behavior and send two instant start/end events containing an info about new tag
-        // 1. onStart/onMove/onEnd can be still dispatched after, if keyboard change size (numeric -> alphabetic type)
-        // 2. event should be send only when keyboard is visible, since this event arrives earlier -> `tag` will be
-        // 100% included in onStart/onMove/onEnd life cycles, but triggering onStart/onEnd several time
-        // can bring breaking changes
-        context.dispatchEvent(
-          eventPropagationView.id,
-          KeyboardTransitionEvent(
-            surfaceId,
+  private val focusListener =
+    OnGlobalFocusChangeListener { oldFocus, newFocus ->
+      if (newFocus is ReactEditText) {
+        viewTagFocused = newFocus.id
+
+        // keyboard is visible and focus has been changed
+        if (this.isKeyboardVisible && oldFocus !== null) {
+          // imitate iOS behavior and send two instant start/end events containing an info about new tag
+          // 1. onStart/onMove/onEnd can be still dispatched after, if keyboard change size (numeric -> alphabetic type)
+          // 2. event should be send only when keyboard is visible, since this event arrives earlier -> `tag` will be
+          // 100% included in onStart/onMove/onEnd life cycles, but triggering onStart/onEnd several time
+          // can bring breaking changes
+          context.dispatchEvent(
             eventPropagationView.id,
-            "topKeyboardMoveStart",
-            this.persistentKeyboardHeight,
-            1.0,
-            0,
-            viewTagFocused,
-          ),
-        )
-        context.dispatchEvent(
-          eventPropagationView.id,
-          KeyboardTransitionEvent(
-            surfaceId,
+            KeyboardTransitionEvent(
+              surfaceId,
+              eventPropagationView.id,
+              "topKeyboardMoveStart",
+              this.persistentKeyboardHeight,
+              1.0,
+              0,
+              viewTagFocused,
+            ),
+          )
+          context.dispatchEvent(
             eventPropagationView.id,
-            "topKeyboardMoveEnd",
-            this.persistentKeyboardHeight,
-            1.0,
-            0,
-            viewTagFocused,
-          ),
-        )
-        context.emitEvent("KeyboardController::keyboardWillShow", getEventParams(this.persistentKeyboardHeight))
-        context.emitEvent("KeyboardController::keyboardDidShow", getEventParams(this.persistentKeyboardHeight))
+            KeyboardTransitionEvent(
+              surfaceId,
+              eventPropagationView.id,
+              "topKeyboardMoveEnd",
+              this.persistentKeyboardHeight,
+              1.0,
+              0,
+              viewTagFocused,
+            ),
+          )
+          context.emitEvent("KeyboardController::keyboardWillShow", getEventParams(this.persistentKeyboardHeight))
+          context.emitEvent("KeyboardController::keyboardDidShow", getEventParams(this.persistentKeyboardHeight))
+        }
       }
     }
-  }
   private var layoutObserver: FocusedInputObserver? = null
 
   init {
@@ -113,7 +125,10 @@ class KeyboardAnimationCallback(
    * have to implement `onApplyWindowInsets` listener and simulate onStart/onProgress/onEnd
    * events when keyboard changes its size.
    */
-  override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
+  override fun onApplyWindowInsets(
+    v: View,
+    insets: WindowInsetsCompat,
+  ): WindowInsetsCompat {
     val keyboardHeight = getCurrentKeyboardHeight()
     // when keyboard appears values will be (false && true)
     // when keyboard disappears values will be (true && false)
@@ -142,7 +157,7 @@ class KeyboardAnimationCallback(
       this.onKeyboardResized(keyboardHeight)
     }
 
-    return WindowInsetsCompat.CONSUMED
+    return insets
   }
 
   @Suppress("detekt:ReturnCount")
@@ -150,7 +165,7 @@ class KeyboardAnimationCallback(
     animation: WindowInsetsAnimationCompat,
     bounds: WindowInsetsAnimationCompat.BoundsCompat,
   ): WindowInsetsAnimationCompat.BoundsCompat {
-    if (!animation.isKeyboardAnimation) {
+    if (!animation.isKeyboardAnimation || isSuspended) {
       return bounds
     }
 
@@ -206,7 +221,13 @@ class KeyboardAnimationCallback(
     // onProgress() is called when any of the running animations progress...
 
     // ignore non-keyboard animation or animation that we intentionally want to skip
-    runningAnimations.find { it.isKeyboardAnimation && !animationsToSkip.contains(it) } ?: return insets
+    val shouldSkipAnimation =
+      runningAnimations.find {
+        it.isKeyboardAnimation && !animationsToSkip.contains(it)
+      } == null
+    if (isSuspended || shouldSkipAnimation) {
+      return insets
+    }
 
     // First we get the insets which are potentially deferred
     val typesInset = insets.getInsets(config.deferredInsetTypes)
@@ -218,9 +239,10 @@ class KeyboardAnimationCallback(
     if (config.hasTranslucentNavigationBar) {
       otherInset = Insets.NONE
     }
-    val diff = Insets.subtract(typesInset, otherInset).let {
-      Insets.max(it, Insets.NONE)
-    }
+    val diff =
+      Insets.subtract(typesInset, otherInset).let {
+        Insets.max(it, Insets.NONE)
+      }
     val diffY = (diff.bottom - diff.top).toFloat()
     val height = diffY.dp
 
@@ -256,7 +278,7 @@ class KeyboardAnimationCallback(
   override fun onEnd(animation: WindowInsetsAnimationCompat) {
     super.onEnd(animation)
 
-    if (!animation.isKeyboardAnimation) {
+    if (!animation.isKeyboardAnimation || isSuspended) {
       return
     }
 
@@ -305,10 +327,13 @@ class KeyboardAnimationCallback(
     duration = 0
   }
 
-  fun syncKeyboardPosition() {
-    val keyboardHeight = getCurrentKeyboardHeight()
+  fun syncKeyboardPosition(
+    height: Double? = null,
+    isVisible: Boolean? = null,
+  ) {
+    val keyboardHeight = height ?: getCurrentKeyboardHeight()
     // update internal state
-    isKeyboardVisible = isKeyboardVisible()
+    isKeyboardVisible = isVisible ?: isKeyboardVisible()
     prevKeyboardHeight = keyboardHeight
     isTransitioning = false
     duration = 0