react-native-keyboard-controller 1.13.4 → 1.14.1

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

@@ -20,14 +20,17 @@ import com.reactnativekeyboardcontroller.interactive.interpolators.LinearInterpo
 import kotlin.math.absoluteValue
 import kotlin.math.roundToInt
 
-val interpolators = mapOf(
-  "linear" to LinearInterpolator(),
-  "ios" to IosInterpolator(),
-)
+val interpolators =
+  mapOf(
+    "linear" to LinearInterpolator(),
+    "ios" to IosInterpolator(),
+  )
 
 @Suppress("detekt:TooManyFunctions")
 @SuppressLint("ViewConstructor")
-class KeyboardGestureAreaReactViewGroup(private val reactContext: ThemedReactContext) : ReactViewGroup(reactContext) {
+class KeyboardGestureAreaReactViewGroup(
+  private val reactContext: ThemedReactContext,
+) : ReactViewGroup(reactContext) {
   // internal state management
   private var isHandling = false
   private var lastTouchX = 0f
@@ -127,12 +130,13 @@ class KeyboardGestureAreaReactViewGroup(private val reactContext: ThemedReactCon
         }
         // 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(),
-          offset,
-        )
+        val moveBy =
+          this.interpolator.interpolate(
+            dy.roundToInt(),
+            this.getWindowHeight() - event.rawY.toInt(),
+            controller.getCurrentKeyboardHeight(),
+            offset,
+          )
 
         if (moveBy != 0) {
           controller.insetBy(moveBy)
@@ -141,8 +145,10 @@ class KeyboardGestureAreaReactViewGroup(private val reactContext: ThemedReactCon
         !controller.isInsetAnimationRequestPending() &&
         shouldStartRequest(
           dy = dy,
-          imeVisible = ViewCompat.getRootWindowInsets(this)
-            ?.isVisible(WindowInsetsCompat.Type.ime()) == true,
+          imeVisible =
+            ViewCompat
+              .getRootWindowInsets(this)
+              ?.isVisible(WindowInsetsCompat.Type.ime()) == true,
         )
       ) {
         // If we don't currently have control (and a request isn't pending),
@@ -210,7 +216,10 @@ class KeyboardGestureAreaReactViewGroup(private val reactContext: ThemedReactCon
    * 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 {
+  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

package/android/src/main/java/com/reactnativekeyboardcontroller/views/overlay/OverKeyboardHostShadowNode.kt

@@ -0,0 +1,30 @@
+package com.reactnativekeyboardcontroller.views.overlay
+
+import com.facebook.react.uimanager.LayoutShadowNode
+import com.facebook.react.uimanager.ReactShadowNodeImpl
+import com.reactnativekeyboardcontroller.extensions.getDisplaySize
+
+/**
+ * We implement the OverKeyboardView by using an Android WindowManager. That will fill the entire window of the
+ * application. To get layout to work properly, we need to layout all the elements within the
+ * OverKeyboardView's inner content view as if they can fill the entire window. To do that, we need to
+ * explicitly set the styleWidth and styleHeight on the LayoutShadowNode of the child of this node
+ * to be the window size. This will then cause the children of the Modal to layout as if they can
+ * fill the window.
+ */
+internal class OverKeyboardHostShadowNode : LayoutShadowNode() {
+  /**
+   * We need to set the styleWidth and styleHeight of the one child (represented by the
+   * <View></View> within the <RCTOverKeyboardView></RCTOverKeyboardView> in OverKeyboardView.tsx.
+   * This needs to fill the entire window.
+   */
+  override fun addChildAt(
+    child: ReactShadowNodeImpl,
+    i: Int,
+  ) {
+    super.addChildAt(child, i)
+    val displaySize = themedContext.getDisplaySize()
+    child.setStyleWidth(displaySize.x.toFloat())
+    child.setStyleHeight(displaySize.y.toFloat())
+  }
+}

package/android/src/main/java/com/reactnativekeyboardcontroller/views/overlay/OverKeyboardViewGroup.kt

@@ -0,0 +1,185 @@
+package com.reactnativekeyboardcontroller.views.overlay
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.PixelFormat
+import android.view.MotionEvent
+import android.view.View
+import android.view.WindowManager
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.config.ReactFeatureFlags
+import com.facebook.react.uimanager.JSPointerDispatcher
+import com.facebook.react.uimanager.JSTouchDispatcher
+import com.facebook.react.uimanager.RootView
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.views.view.ReactViewGroup
+
+@SuppressLint("ViewConstructor")
+class OverKeyboardHostView(
+  private val reactContext: ThemedReactContext,
+) : ReactViewGroup(reactContext) {
+  private val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, this.id)
+  private var windowManager: WindowManager = reactContext.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+  private var hostView: OverKeyboardRootViewGroup = OverKeyboardRootViewGroup(reactContext)
+
+  init {
+    hostView.eventDispatcher = dispatcher
+  }
+
+  // region life cycles
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+
+    hide()
+  }
+
+  override fun addView(
+    child: View?,
+    index: Int,
+  ) {
+    UiThreadUtil.assertOnUiThread()
+    hostView.addView(child, index)
+  }
+
+  override fun getChildCount(): Int = hostView.childCount
+
+  override fun getChildAt(index: Int): View? = hostView.getChildAt(index)
+
+  override fun removeView(child: View?) {
+    UiThreadUtil.assertOnUiThread()
+
+    if (child != null) {
+      hostView.removeView(child)
+    }
+  }
+
+  override fun removeViewAt(index: Int) {
+    UiThreadUtil.assertOnUiThread()
+    val child = getChildAt(index)
+    hostView.removeView(child)
+  }
+
+  override fun onLayout(
+    changed: Boolean,
+    l: Int,
+    t: Int,
+    r: Int,
+    b: Int,
+  ) {
+    // Do nothing as we are laid out by UIManager
+  }
+  // endregion
+
+  fun show() {
+    val layoutParams =
+      WindowManager.LayoutParams(
+        WindowManager.LayoutParams.MATCH_PARENT,
+        WindowManager.LayoutParams.MATCH_PARENT,
+        // This type ensures it floats over other application windows but under system windows
+        WindowManager.LayoutParams.TYPE_APPLICATION_PANEL,
+        // Ensures touches outside the view pass through to other windows
+        WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS,
+        PixelFormat.TRANSLUCENT,
+      )
+
+    windowManager.addView(hostView, layoutParams)
+  }
+
+  fun hide() {
+    if (hostView.isAttached) {
+      windowManager.removeView(hostView)
+    }
+  }
+}
+
+@SuppressLint("ViewConstructor")
+class OverKeyboardRootViewGroup(
+  private val reactContext: ThemedReactContext,
+) : ReactViewGroup(reactContext),
+  RootView {
+  private val jsTouchDispatcher: JSTouchDispatcher = JSTouchDispatcher(this)
+  private var jsPointerDispatcher: JSPointerDispatcher? = null
+  internal var eventDispatcher: EventDispatcher? = null
+  internal var isAttached = false
+
+  init {
+    if (ReactFeatureFlags.dispatchPointerEvents) {
+      jsPointerDispatcher = JSPointerDispatcher(this)
+    }
+  }
+
+  // region life cycles
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    isAttached = true
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+    isAttached = false
+  }
+  // endregion
+
+  // region Touch events handling
+  override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { eventDispatcher ->
+      jsTouchDispatcher.handleTouchEvent(event, eventDispatcher)
+      jsPointerDispatcher?.handleMotionEvent(event, eventDispatcher, true)
+    }
+    return super.onInterceptTouchEvent(event)
+  }
+
+  @SuppressLint("ClickableViewAccessibility")
+  override fun onTouchEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { eventDispatcher ->
+      jsTouchDispatcher.handleTouchEvent(event, eventDispatcher)
+      jsPointerDispatcher?.handleMotionEvent(event, eventDispatcher, false)
+    }
+    super.onTouchEvent(event)
+    // In case when there is no children interested in handling touch event, we return true from
+    // the root view in order to receive subsequent events related to that gesture
+    return true
+  }
+
+  override fun onInterceptHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { jsPointerDispatcher?.handleMotionEvent(event, it, true) }
+    return super.onHoverEvent(event)
+  }
+
+  override fun onHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { jsPointerDispatcher?.handleMotionEvent(event, it, false) }
+    return super.onHoverEvent(event)
+  }
+
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    // No-op - override in order to still receive events to onInterceptTouchEvent
+    // even when some other view disallow that
+  }
+  // endregion
+
+  // region RootView methods
+  override fun onChildStartedNativeGesture(
+    childView: View,
+    ev: MotionEvent,
+  ) {
+    eventDispatcher?.let { eventDispatcher ->
+      jsTouchDispatcher.onChildStartedNativeGesture(ev, eventDispatcher)
+      jsPointerDispatcher?.onChildStartedNativeGesture(childView, ev, eventDispatcher)
+    }
+  }
+
+  override fun onChildEndedNativeGesture(
+    childView: View,
+    ev: MotionEvent,
+  ) {
+    eventDispatcher?.let { jsTouchDispatcher.onChildEndedNativeGesture(ev, it) }
+    jsPointerDispatcher?.onChildEndedNativeGesture()
+  }
+
+  override fun handleException(t: Throwable) {
+    reactContext.reactApplicationContext.handleException(RuntimeException(t))
+  }
+  // endregion
+}

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

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

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

@@ -7,31 +7,40 @@ import com.facebook.react.views.view.ReactViewManager
 import com.reactnativekeyboardcontroller.managers.KeyboardControllerViewManagerImpl
 import com.reactnativekeyboardcontroller.views.EdgeToEdgeReactViewGroup
 
-class KeyboardControllerViewManager(mReactContext: ReactApplicationContext) : ReactViewManager() {
+class KeyboardControllerViewManager(
+  mReactContext: ReactApplicationContext,
+) : ReactViewManager() {
   private val manager = KeyboardControllerViewManagerImpl(mReactContext)
 
   override fun getName(): String = KeyboardControllerViewManagerImpl.NAME
 
-  override fun createViewInstance(reactContext: ThemedReactContext): EdgeToEdgeReactViewGroup {
-    return manager.createViewInstance(reactContext)
-  }
+  override fun createViewInstance(reactContext: ThemedReactContext): EdgeToEdgeReactViewGroup =
+    manager.createViewInstance(reactContext)
 
   @ReactProp(name = "enabled")
-  fun setEnabled(view: EdgeToEdgeReactViewGroup, enabled: Boolean) {
+  fun setEnabled(
+    view: EdgeToEdgeReactViewGroup,
+    enabled: Boolean,
+  ) {
     manager.setEnabled(view, enabled)
   }
 
   @ReactProp(name = "statusBarTranslucent")
-  fun setStatusBarTranslucent(view: EdgeToEdgeReactViewGroup, isStatusBarTranslucent: Boolean) {
+  fun setStatusBarTranslucent(
+    view: EdgeToEdgeReactViewGroup,
+    isStatusBarTranslucent: Boolean,
+  ) {
     manager.setStatusBarTranslucent(view, isStatusBarTranslucent)
   }
 
   @ReactProp(name = "navigationBarTranslucent")
-  fun setNavigationBarTranslucent(view: EdgeToEdgeReactViewGroup, isNavigationBarTranslucent: Boolean) {
+  fun setNavigationBarTranslucent(
+    view: EdgeToEdgeReactViewGroup,
+    isNavigationBarTranslucent: Boolean,
+  ) {
     manager.setNavigationBarTranslucent(view, isNavigationBarTranslucent)
   }
 
-  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
-    return manager.getExportedCustomDirectEventTypeConstants()
-  }
+  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> =
+    manager.getExportedCustomDirectEventTypeConstants()
 }

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

@@ -7,32 +7,45 @@ import com.facebook.react.views.view.ReactViewManager
 import com.reactnativekeyboardcontroller.managers.KeyboardGestureAreaViewManagerImpl
 import com.reactnativekeyboardcontroller.views.KeyboardGestureAreaReactViewGroup
 
-class KeyboardGestureAreaViewManager(mReactContext: ReactApplicationContext) : ReactViewManager() {
+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)
-  }
+  override fun createViewInstance(reactContext: ThemedReactContext): KeyboardGestureAreaReactViewGroup =
+    manager.createViewInstance(reactContext)
 
   @ReactProp(name = "offset")
-  fun setInterpolator(view: KeyboardGestureAreaReactViewGroup, offset: Double) {
+  fun setInterpolator(
+    view: KeyboardGestureAreaReactViewGroup,
+    offset: Double,
+  ) {
     manager.setOffset(view, offset)
   }
 
   @ReactProp(name = "interpolator")
-  fun setInterpolator(view: KeyboardGestureAreaReactViewGroup, interpolator: String) {
+  fun setInterpolator(
+    view: KeyboardGestureAreaReactViewGroup,
+    interpolator: String,
+  ) {
     manager.setInterpolator(view, interpolator)
   }
 
   @ReactProp(name = "showOnSwipeUp")
-  fun setScrollKeyboardOnScreenWhenNotVisible(view: KeyboardGestureAreaReactViewGroup, value: Boolean) {
+  fun setScrollKeyboardOnScreenWhenNotVisible(
+    view: KeyboardGestureAreaReactViewGroup,
+    value: Boolean,
+  ) {
     manager.setScrollKeyboardOnScreenWhenNotVisible(view, value)
   }
 
   @ReactProp(name = "enableSwipeToDismiss")
-  fun setScrollKeyboardOffScreenWhenVisible(view: KeyboardGestureAreaReactViewGroup, value: Boolean) {
+  fun setScrollKeyboardOffScreenWhenVisible(
+    view: KeyboardGestureAreaReactViewGroup,
+    value: Boolean,
+  ) {
     manager.setScrollKeyboardOffScreenWhenVisible(view, value)
   }
 }

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

@@ -0,0 +1,33 @@
+package com.reactnativekeyboardcontroller
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.LayoutShadowNode
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.reactnativekeyboardcontroller.managers.OverKeyboardViewManagerImpl
+import com.reactnativekeyboardcontroller.views.overlay.OverKeyboardHostShadowNode
+import com.reactnativekeyboardcontroller.views.overlay.OverKeyboardHostView
+
+class OverKeyboardViewManager(
+  mReactContext: ReactApplicationContext,
+) : ViewGroupManager<OverKeyboardHostView>() {
+  private val manager = OverKeyboardViewManagerImpl(mReactContext)
+
+  override fun getName(): String = OverKeyboardViewManagerImpl.NAME
+
+  override fun createViewInstance(reactContext: ThemedReactContext): OverKeyboardHostView =
+    manager.createViewInstance(reactContext)
+
+  override fun createShadowNodeInstance(): LayoutShadowNode = OverKeyboardHostShadowNode()
+
+  override fun getShadowNodeClass(): Class<out LayoutShadowNode> = OverKeyboardHostShadowNode::class.java
+
+  @ReactProp(name = "visible")
+  fun setVisible(
+    view: OverKeyboardHostView,
+    value: Boolean,
+  ) {
+    manager.setVisible(view, value)
+  }
+}

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

@@ -7,8 +7,9 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.reactnativekeyboardcontroller.modules.StatusBarManagerCompatModuleImpl
 
-class StatusBarManagerCompatModule(mReactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(mReactContext) {
+class StatusBarManagerCompatModule(
+  mReactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(mReactContext) {
   private val module = StatusBarManagerCompatModuleImpl(mReactContext)
 
   override fun getName(): String = StatusBarManagerCompatModuleImpl.NAME
@@ -20,7 +21,10 @@ class StatusBarManagerCompatModule(mReactContext: ReactApplicationContext) :
 
   @ReactMethod
   @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
-  private fun setColor(color: Int, animated: Boolean) {
+  private fun setColor(
+    color: Int,
+    animated: Boolean,
+  ) {
     module.setColor(color, animated)
   }
 

package/android/src/test/java/com/reactnativekeyboardcontroller/traversal/ViewHierarchyNavigatorTest.kt

@@ -36,8 +36,16 @@ class ViewHierarchyNavigatorTest {
 
     editText1 = EditText(context).apply { id = 1 }
     editText2 = EditText(context).apply { id = 2 }
-    editText3 = EditText(context).apply { id = 3; isEnabled = false }
-    editText4 = EditText(context).apply { id = 4; isEnabled = false }
+    editText3 =
+      EditText(context).apply {
+        id = 3
+        isEnabled = false
+      }
+    editText4 =
+      EditText(context).apply {
+        id = 4
+        isEnabled = false
+      }
     editText5 = EditText(context).apply { id = 5 }
     editText6 = EditText(context).apply { id = 6 }
     editText7 = EditText(context).apply { id = 7 }
@@ -48,25 +56,26 @@ class ViewHierarchyNavigatorTest {
     editText12 = EditText(context).apply { id = 12 }
     editText13 = EditText(context).apply { id = 13 }
 
-    layout = LinearLayout(context).apply {
-      addView(editText1)
-      addView(editText2)
-      addView(editText3)
-      addView(editText4)
-      addView(
-        LinearLayout(context).apply {
-          addView(editText5)
-          addView(editText6)
-          addView(editText7)
-        },
-      )
-      addView(editText8)
-      addView(editText9)
-      addView(editText10)
-      addView(editText11)
-      addView(editText12)
-      addView(editText13)
-    }
+    layout =
+      LinearLayout(context).apply {
+        addView(editText1)
+        addView(editText2)
+        addView(editText3)
+        addView(editText4)
+        addView(
+          LinearLayout(context).apply {
+            addView(editText5)
+            addView(editText6)
+            addView(editText7)
+          },
+        )
+        addView(editText8)
+        addView(editText9)
+        addView(editText10)
+        addView(editText11)
+        addView(editText12)
+        addView(editText13)
+      }
   }
 
   @Test

package/ios/KeyboardController-Bridging-Header.h

@@ -1,3 +1,4 @@
+#import <React/RCTTouchHandler.h>
 #import <React/RCTUIManager.h>
 #import <React/RCTUITextView.h>
 #import <React/RCTViewManager.h>

package/ios/{core → animations}/KeyboardAnimation.swift

@@ -6,6 +6,7 @@
 //
 
 import Foundation
+import QuartzCore
 
 protocol KeyboardAnimationProtocol {
   var startTime: CFTimeInterval { get }

package/ios/{core → animations}/SpringAnimation.swift

@@ -10,7 +10,7 @@ import Foundation
 import QuartzCore
 
 // swiftlint:disable identifier_name
-public class SpringAnimation: KeyboardAnimation {
+public final class SpringAnimation: KeyboardAnimation {
   // internal variables
   private let zeta: Double // Damping ratio
   private let omega0: Double // Undamped angular frequency of the oscillator

package/ios/{core → animations}/TimingAnimation.swift

@@ -15,13 +15,13 @@ import QuartzCore
  * This class calculates the progress of animations based on Bézier curve control points.
  * For more details on the Bézier curves, see [Desmos Graph](https://www.desmos.com/calculator/eynenh1aga?lang=en).
  */
-public class TimingAnimation: KeyboardAnimation {
+public final class TimingAnimation: KeyboardAnimation {
   private let p1: CGPoint
   private let p2: CGPoint
 
   init(animation: CABasicAnimation, fromValue: Double, toValue: Double) {
     let timingFunction = animation.timingFunction
-    var controlPoints: [Float] = [0, 0, 0, 0]
+    var controlPoints: ContiguousArray<Float> = ContiguousArray([0, 0, 0, 0])
     timingFunction?.getControlPoint(at: 1, values: &controlPoints[0])
     timingFunction?.getControlPoint(at: 2, values: &controlPoints[2])
     let p1 = CGPoint(x: CGFloat(controlPoints[0]), y: CGFloat(controlPoints[1]))
@@ -33,7 +33,20 @@ public class TimingAnimation: KeyboardAnimation {
     super.init(fromValue: fromValue, toValue: toValue, animation: animation)
   }
 
-  func bezier(t: CGFloat, valueForPoint: (CGPoint) -> CGFloat) -> CGFloat {
+  // public functions
+  override func valueAt(time: Double) -> Double {
+    let x = time * Double(speed)
+    let frames = (animation?.duration ?? 0.0) * Double(speed)
+    let fraction = min(x / frames, 1)
+    let t = findTForX(xTarget: fraction)
+
+    let progress = bezierY(t: t)
+
+    return fromValue + (toValue - fromValue) * CGFloat(progress)
+  }
+
+  // private functions
+  private func bezier(t: CGFloat, valueForPoint: (CGPoint) -> CGFloat) -> CGFloat {
     let u = 1 - t
     let tt = t * t
     let uu = u * u
@@ -49,27 +62,15 @@ public class TimingAnimation: KeyboardAnimation {
     return term1 + term2 + term3
   }
 
-  func bezierY(t: CGFloat) -> CGFloat {
+  private func bezierY(t: CGFloat) -> CGFloat {
     return bezier(t: t) { $0.y }
   }
 
-  func bezierX(t: CGFloat) -> CGFloat {
+  private func bezierX(t: CGFloat) -> CGFloat {
     return bezier(t: t) { $0.x }
   }
 
-  // public functions
-  override func valueAt(time: Double) -> Double {
-    let x = time * Double(speed)
-    let frames = (animation?.duration ?? 0.0) * Double(speed)
-    let fraction = min(x / frames, 1)
-    let t = findTForX(xTarget: fraction)
-
-    let progress = bezierY(t: t)
-
-    return fromValue + (toValue - fromValue) * CGFloat(progress)
-  }
-
-  func findTForX(xTarget: CGFloat, epsilon: CGFloat = 0.0001, maxIterations: Int = 100) -> CGFloat {
+  private func findTForX(xTarget: CGFloat, epsilon: CGFloat = 0.0001, maxIterations: Int = 100) -> CGFloat {
     var t: CGFloat = 0.5 // Start with an initial guess of t = 0.5
     for _ in 0 ..< maxIterations {
       let currentX = bezierX(t: t) // Compute the x-coordinate at t
@@ -84,7 +85,7 @@ public class TimingAnimation: KeyboardAnimation {
     return t // Return the approximation of t
   }
 
-  func bezierDerivative(t: CGFloat, valueForPoint: (CGPoint) -> CGFloat) -> CGFloat {
+  private func bezierDerivative(t: CGFloat, valueForPoint: (CGPoint) -> CGFloat) -> CGFloat {
     let u = 1 - t
     let uu = u * u
     let tt = t * t
@@ -100,7 +101,7 @@ public class TimingAnimation: KeyboardAnimation {
     return term1 + term2 + term3
   }
 
-  func bezierXDerivative(t: CGFloat) -> CGFloat {
+  private func bezierXDerivative(t: CGFloat) -> CGFloat {
     return bezierDerivative(t: t) { $0.x }
   }
 }

package/ios/extensions/UIApplication.swift

@@ -9,6 +9,22 @@ import Foundation
 import UIKit
 
 public extension UIApplication {
+  var activeWindow: UIWindow? {
+    if #available(iOS 13.0, *) {
+      for scene in connectedScenes {
+        if scene.activationState == .foregroundActive,
+           let windowScene = scene as? UIWindowScene,
+           let keyWindow = windowScene.windows.first(where: { $0.isKeyWindow })
+        {
+          return keyWindow
+        }
+      }
+      return nil
+    } else {
+      return windows.last { $0.isKeyWindow }
+    }
+  }
+
   static func topViewController(
     base: UIViewController? = UIApplication.shared.keyWindow?.rootViewController
   ) -> UIViewController? {

package/ios/extensions/UIResponder.swift

@@ -56,10 +56,7 @@ public extension Optional where Wrapped: UIResponder {
          !(currentView is UITextView),
          scrollView.frame.width >= scrollView.contentSize.width,
          scrollView.isScrollEnabled
-      // it was fixed in swiftlint https://github.com/realm/SwiftLint/issues/3756 but a new release is not available yet
-      // swiftlint:disable all
       {
-        // swiftlint:enable all
         return scrollView.reactViewTag
       }