react-native-gesture-handler 3.0.0-beta.3 → 3.0.0-beta.5

package/android/src/main/java/com/swmansion/gesturehandler/core/GestureHandler.kt

@@ -9,7 +9,6 @@ import android.view.MotionEvent
 import android.view.MotionEvent.PointerCoords
 import android.view.MotionEvent.PointerProperties
 import android.view.View
-import androidx.core.view.isNotEmpty
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReadableMap
@@ -48,6 +47,26 @@ open class GestureHandler {
       }
     }
 
+  /**
+   * The view whose coordinate space should be used when reporting event positions to JS.
+   *
+   * Handlers attached via the V3 NativeDetector are registered against the DetectorView wrapper,
+   * which never carries user-applied transforms — those live on its child. When the detector has
+   * exactly one child we descend into it so reported coordinates match the visible (transformed)
+   * view, the same coordinate space V2 and the V3 VirtualGestureDetector report in. With
+   * multiple children there is no JS-side way to disambiguate which child caught the pointer,
+   * so we keep the detector itself as the reference frame.
+   */
+  val coordinateView: View?
+    get() {
+      val v = view
+      return if (v is RNGestureHandlerDetectorView && v.childCount == 1) {
+        v.getChildAt(0)
+      } else {
+        v
+      }
+    }
+
   var state = STATE_UNDETERMINED
     private set
   var x = 0f
@@ -83,6 +102,7 @@ open class GestureHandler {
   var needsPointerData = false
   var dispatchesAnimatedEvents = false
   var dispatchesReanimatedEvents = false
+  var cancelsJSResponder = true
 
   private var hitSlop: FloatArray? = null
   var eventCoalescingKey: Short = 0
@@ -113,6 +133,11 @@ open class GestureHandler {
   var isAwaiting = false
   var shouldResetProgress = false
 
+  /**
+   * Whether the handler represents a continuous gesture rather than a discrete one.
+   */
+  open val isContinuous: Boolean = false
+
   open fun dispatchStateChange(newState: Int, prevState: Int) {
     onTouchEventListener?.onStateChange(this, newState, prevState)
   }
@@ -137,6 +162,7 @@ open class GestureHandler {
     mouseButton = DEFAULT_MOUSE_BUTTON
     dispatchesAnimatedEvents = DEFAULT_DISPATCHES_ANIMATED_EVENTS
     dispatchesReanimatedEvents = DEFAULT_DISPATCHES_REANIMATED_EVENTS
+    cancelsJSResponder = DEFAULT_CANCELS_JS_RESPONDER
   }
 
   fun hasCommonPointers(other: GestureHandler): Boolean {
@@ -387,42 +413,13 @@ open class GestureHandler {
 
     numberOfPointers = adaptedTransformedEvent.pointerCount
 
-    // TODO: this is likely wrong, and the transformed event itself should be
-    // in the coordinate system of the child view, but I'm not sure of the
-    // consequences
-    val detectorView = hostDetectorView
-    if (detectorView != null && view == detectorView && detectorView.isNotEmpty()) {
-      val outPoint = PointF()
-      var foundChild = false
-
-      for (i in 0 until detectorView.childCount) {
-        val child = detectorView.getChildAt(i)
-        GestureHandlerOrchestrator.transformPointToChildViewCoords(
-          adaptedTransformedEvent.x,
-          adaptedTransformedEvent.y,
-          detectorView,
-          child,
-          outPoint,
-        )
-        if (isWithinBounds(child, outPoint.x, outPoint.y)) {
-          x = outPoint.x
-          y = outPoint.y
-          isWithinBounds = true
-          foundChild = true
-          break
-        }
-      }
-
-      if (!foundChild) {
-        x = adaptedTransformedEvent.x
-        y = adaptedTransformedEvent.y
-        isWithinBounds = false
-      }
-    } else {
-      x = adaptedTransformedEvent.x
-      y = adaptedTransformedEvent.y
-      isWithinBounds = isWithinBounds(view, x, y)
-    }
+    x = adaptedTransformedEvent.x
+    y = adaptedTransformedEvent.y
+    // The orchestrator transforms incoming events into the coordinate space of the detector's
+    // child (when the handler is attached to a NativeDetector wrapper), so bounds-checking must
+    // also use that child rather than the wrapper, otherwise hit-testing would ignore the user's
+    // transforms applied to the visible view.
+    isWithinBounds = isWithinBounds(coordinateView, x, y)
 
     if (shouldCancelWhenOutside) {
       if (!isWithinBounds && (state == STATE_ACTIVE || state == STATE_BEGAN)) {
@@ -693,6 +690,8 @@ open class GestureHandler {
     return interactionController?.shouldHandlerBeCancelledBy(this, handler) ?: false
   }
 
+  open fun shouldBeginWithRecordedHandlers(recorded: List<GestureHandler>): Boolean = true
+
   fun isWithinBounds(view: View?, posX: Float, posY: Float): Boolean {
     if (RNSVGHitTester.isSvgElement(view!!)) {
       return RNSVGHitTester.hitTest(view, posX, posY)
@@ -870,7 +869,7 @@ open class GestureHandler {
    * This method modifies and transforms the received point.
    */
   protected fun transformPoint(point: PointF): PointF =
-    orchestrator?.transformPointToViewCoords(this.view, point) ?: run {
+    orchestrator?.transformPointToViewCoords(coordinateView, point) ?: run {
       point.x = Float.NaN
       point.y = Float.NaN
       point
@@ -961,6 +960,9 @@ open class GestureHandler {
       if (config.hasKey(KEY_TEST_ID)) {
         handler.testID = config.getString(KEY_TEST_ID)
       }
+      if (config.hasKey(KEY_CANCELS_JS_RESPONDER)) {
+        handler.cancelsJSResponder = config.getBoolean(KEY_CANCELS_JS_RESPONDER)
+      }
     }
 
     abstract fun createEventBuilder(handler: T): GestureHandlerEventDataBuilder<T>
@@ -983,6 +985,7 @@ open class GestureHandler {
       private const val KEY_HIT_SLOP_WIDTH = "width"
       private const val KEY_HIT_SLOP_HEIGHT = "height"
       private const val KEY_TEST_ID = "testID"
+      private const val KEY_CANCELS_JS_RESPONDER = "cancelsJSResponder"
 
       private fun handleHitSlopProperty(handler: GestureHandler, config: ReadableMap) {
         if (config.getType(KEY_HIT_SLOP) == ReadableType.Number) {
@@ -1046,6 +1049,7 @@ open class GestureHandler {
     private const val DEFAULT_MOUSE_BUTTON = 0
     private const val DEFAULT_DISPATCHES_ANIMATED_EVENTS = false
     private const val DEFAULT_DISPATCHES_REANIMATED_EVENTS = false
+    private const val DEFAULT_CANCELS_JS_RESPONDER = true
 
     const val STATE_UNDETERMINED = 0
     const val STATE_FAILED = 1

package/android/src/main/java/com/swmansion/gesturehandler/core/GestureHandlerOrchestrator.kt

@@ -19,6 +19,7 @@ class GestureHandlerOrchestrator(
   private val handlerRegistry: GestureHandlerRegistry,
   private val viewConfigHelper: ViewConfigurationHelper,
   private val rootView: ViewGroup,
+  private val onJSResponderCancelListener: OnJSResponderCancelListener,
 ) {
   /**
    * Minimum alpha (value from 0 to 1) that should be set to a view so that it can be treated as a
@@ -143,6 +144,14 @@ class GestureHandlerOrchestrator(
   /*package*/
   fun onHandlerStateChange(handler: GestureHandler, newState: Int, prevState: Int) {
     handlingChangeSemaphore += 1
+
+    if (isFinished(newState) && handler.isActive && handler.cancelsJSResponder) {
+      // Check if there are any other active handlers that still request the JS responder to be cancelled.
+      if (gestureHandlers.none { it !== handler && it.isActive && it.cancelsJSResponder }) {
+        onJSResponderCancelListener?.onCancelJSResponderReleased(handler)
+      }
+    }
+
     if (isFinished(newState)) {
       // We have to loop through copy in order to avoid modifying collection
       // while iterating over its elements
@@ -241,6 +250,10 @@ class GestureHandlerOrchestrator(
       return
     }
 
+    if (handler.cancelsJSResponder) {
+      onJSResponderCancelListener?.onCancelJSResponderRequested(handler)
+    }
+
     handler.dispatchStateChange(GestureHandler.STATE_ACTIVE, GestureHandler.STATE_BEGAN)
 
     if (currentState != GestureHandler.STATE_ACTIVE) {
@@ -297,7 +310,7 @@ class GestureHandlerOrchestrator(
     }
 
     val action = sourceEvent.actionMasked
-    val event = transformEventToViewCoords(handler.view, MotionEvent.obtain(sourceEvent))
+    val event = transformEventToViewCoords(handler.coordinateView, MotionEvent.obtain(sourceEvent))
 
     if (handler.needsPointerData) {
       handler.updatePointerData(event, sourceEvent)
@@ -349,11 +362,19 @@ class GestureHandlerOrchestrator(
     if (view === wrapperView) {
       return true
     }
-    var parent = view.parent
-    while (parent != null && parent !== wrapperView) {
-      parent = parent.parent
+    var current: View = view
+    while (true) {
+      val parent = current.parent as? ViewGroup ?: return false
+
+      when {
+        // A disappearing child (kept drawable for an exit animation, e.g. RNScreens during a
+        // navigation transition) still has `parent` set but is gone from `mChildren`. Treat as
+        // detached - `cancelTouchTarget` already synthesized ACTION_CANCEL into this subtree.
+        parent.indexOfChild(current) < 0 -> return false
+        parent === wrapperView -> return true
+        else -> current = parent
+      }
     }
-    return parent === wrapperView
   }
 
   fun isAnyHandlerActive() = gestureHandlers.any { it.state == GestureHandler.STATE_ACTIVE }
@@ -448,11 +469,16 @@ class GestureHandlerOrchestrator(
       return
     }
 
-    gestureHandlers.add(handler)
     handler.isActive = false
     handler.isAwaiting = false
     handler.activationIndex = Int.MAX_VALUE
     handler.prepare(view, this)
+
+    if (!handler.shouldBeginWithRecordedHandlers(gestureHandlers)) {
+      handler.cancel()
+    }
+
+    gestureHandlers.add(handler)
   }
 
   private fun isViewOverflowingParent(view: View): Boolean {
@@ -606,7 +632,7 @@ class GestureHandlerOrchestrator(
 
     val childrenCount = viewGroup.childCount
     for (i in childrenCount - 1 downTo 0) {
-      val child = viewConfigHelper.getChildInDrawingOrderAtIndex(viewGroup, i)
+      val child = viewGroup.getChildAt(i)
       if (canReceiveEvents(child)) {
         val childPoint = tempPoint
         transformPointToChildViewCoords(coords[0], coords[1], viewGroup, child, childPoint)
@@ -659,7 +685,7 @@ class GestureHandlerOrchestrator(
             is ViewGroup -> {
               extractGestureHandlers(view, coords, pointerId, event).also { found ->
                 // A child view is handling touch, also extract handlers attached to this view
-                if (found) {
+                if (found || view is RNGestureHandlerDetectorView) {
                   recordViewHandlersForPointer(view, coords, pointerId, event)
                 }
               }

package/android/src/main/java/com/swmansion/gesturehandler/core/HoverGestureHandler.kt

@@ -7,10 +7,11 @@ import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
 import com.swmansion.gesturehandler.react.RNGestureHandlerRootHelper
-import com.swmansion.gesturehandler.react.RNViewConfigurationHelper
 import com.swmansion.gesturehandler.react.events.eventbuilders.HoverGestureHandlerEventDataBuilder
 
 class HoverGestureHandler : GestureHandler() {
+  override val isContinuous = true
+
   private var handler: Handler? = null
   private var finishRunnable = Runnable { finish() }
   var stylusData: StylusData = StylusData()
@@ -42,7 +43,7 @@ class HoverGestureHandler : GestureHandler() {
 
     if (rootView is ViewGroup) {
       for (i in 0 until rootView.childCount) {
-        val child = viewConfigHelper.getChildInDrawingOrderAtIndex(rootView, i)
+        val child = rootView.getChildAt(i)
         return isViewDisplayedOverAnother(view, other, child) ?: continue
       }
     }
@@ -143,8 +144,4 @@ class HoverGestureHandler : GestureHandler() {
 
     override fun createEventBuilder(handler: HoverGestureHandler) = HoverGestureHandlerEventDataBuilder(handler)
   }
-
-  companion object {
-    private val viewConfigHelper = RNViewConfigurationHelper()
-  }
 }

package/android/src/main/java/com/swmansion/gesturehandler/core/ManualGestureHandler.kt

@@ -5,6 +5,8 @@ import android.view.MotionEvent
 import com.swmansion.gesturehandler.react.events.eventbuilders.ManualGestureHandlerEventDataBuilder
 
 class ManualGestureHandler : GestureHandler() {
+  override val isContinuous = true
+
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     if (state == STATE_UNDETERMINED) {
       begin()

package/android/src/main/java/com/swmansion/gesturehandler/core/NativeViewGestureHandler.kt

@@ -15,10 +15,13 @@ import com.facebook.react.views.text.ReactTextView
 import com.facebook.react.views.textinput.ReactEditText
 import com.facebook.react.views.view.ReactViewGroup
 import com.swmansion.gesturehandler.react.RNGestureHandlerButtonViewManager
+import com.swmansion.gesturehandler.react.RNGestureHandlerRootHelper
 import com.swmansion.gesturehandler.react.events.eventbuilders.NativeGestureHandlerEventDataBuilder
 import com.swmansion.gesturehandler.react.isScreenReaderOn
 
 class NativeViewGestureHandler : GestureHandler() {
+  override val isContinuous = true
+
   private var shouldActivateOnStart = false
 
   /**
@@ -29,8 +32,19 @@ class NativeViewGestureHandler : GestureHandler() {
   var disallowInterruption = false
     private set
 
+  /**
+   * Composes with [disallowInterruption]. When both are `true`, the handler still resists
+   * discrete gesture peers but yields to continuous peers. No-op when [disallowInterruption] is `false`.
+   */
+  var yieldsToContinuousGestures = false
+    private set
+
   private var hook: NativeViewGestureHandlerHook = defaultHook
 
+  private data class ActiveUpdateSnapshot(val pointerInside: Boolean, val numberOfPointers: Int, val pointerType: Int)
+
+  private var lastActiveUpdate: ActiveUpdateSnapshot? = null
+
   init {
     shouldCancelWhenOutside = true
   }
@@ -39,6 +53,7 @@ class NativeViewGestureHandler : GestureHandler() {
     super.resetConfig()
     shouldActivateOnStart = DEFAULT_SHOULD_ACTIVATE_ON_START
     disallowInterruption = DEFAULT_DISALLOW_INTERRUPTION
+    yieldsToContinuousGestures = DEFAULT_YIELDS_TO_CONTINUOUS_GESTURES
     shouldCancelWhenOutside = DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE
   }
 
@@ -57,12 +72,15 @@ class NativeViewGestureHandler : GestureHandler() {
       // For the `disallowInterruption` to work correctly we need to check the property when
       // accessed as a peer, because simultaneous recognizers can be set on either side of the
       // connection.
-      if (handler.state == STATE_ACTIVE && handler.disallowInterruption) {
+      if (handler.state == STATE_ACTIVE &&
+        handler.disallowInterruption &&
+        !handler.yieldsToContinuousGestures
+      ) {
         // other handler is active and it disallows interruption, we don't want to get into its way
         return false
       }
     }
-    val canBeInterrupted = !disallowInterruption
+    val canBeInterrupted = canBeInterruptedBy(handler)
     val otherState = handler.state
     return if (state == STATE_ACTIVE && otherState == STATE_ACTIVE && canBeInterrupted) {
       // if both handlers are active and the current handler can be interrupted it we return `false`
@@ -77,7 +95,17 @@ class NativeViewGestureHandler : GestureHandler() {
     // otherwise we can only return `true` if already in an active state
   }
 
-  override fun shouldBeCancelledBy(handler: GestureHandler): Boolean = !disallowInterruption
+  override fun shouldBeCancelledBy(handler: GestureHandler): Boolean = canBeInterruptedBy(handler)
+
+  /**
+   * Whether this handler permits [other] to take over the touch stream, given its
+   * `disallowInterruption` and `yieldsToContinuousGestures` configuration.
+   */
+  fun canBeInterruptedBy(other: GestureHandler): Boolean = !disallowInterruption ||
+    (yieldsToContinuousGestures && other.isContinuous)
+
+  override fun shouldBeginWithRecordedHandlers(recorded: List<GestureHandler>): Boolean =
+    hook.shouldBeginWithRecordedHandlers(recorded, this)
 
   override fun onPrepare() {
     when (val view = view) {
@@ -163,6 +191,21 @@ class NativeViewGestureHandler : GestureHandler() {
 
   override fun onReset() {
     this.hook = defaultHook
+    lastActiveUpdate = null
+  }
+
+  override fun dispatchHandlerUpdate(event: MotionEvent) {
+    val snapshot = ActiveUpdateSnapshot(isWithinBounds, numberOfPointers, pointerType)
+    if (snapshot == lastActiveUpdate) {
+      return
+    }
+    lastActiveUpdate = snapshot
+    super.dispatchHandlerUpdate(event)
+  }
+
+  override fun dispatchStateChange(newState: Int, prevState: Int) {
+    lastActiveUpdate = null
+    super.dispatchStateChange(newState, prevState)
   }
 
   override fun wantsToAttachDirectlyToView() = true
@@ -181,6 +224,9 @@ class NativeViewGestureHandler : GestureHandler() {
       if (config.hasKey(KEY_DISALLOW_INTERRUPTION)) {
         handler.disallowInterruption = config.getBoolean(KEY_DISALLOW_INTERRUPTION)
       }
+      if (config.hasKey(KEY_YIELDS_TO_CONTINUOUS_GESTURES)) {
+        handler.yieldsToContinuousGestures = config.getBoolean(KEY_YIELDS_TO_CONTINUOUS_GESTURES)
+      }
     }
 
     override fun createEventBuilder(handler: NativeViewGestureHandler) = NativeGestureHandlerEventDataBuilder(handler)
@@ -188,6 +234,7 @@ class NativeViewGestureHandler : GestureHandler() {
     companion object {
       private const val KEY_SHOULD_ACTIVATE_ON_START = "shouldActivateOnStart"
       private const val KEY_DISALLOW_INTERRUPTION = "disallowInterruption"
+      private const val KEY_YIELDS_TO_CONTINUOUS_GESTURES = "yieldsToContinuousGestures"
     }
   }
 
@@ -195,6 +242,7 @@ class NativeViewGestureHandler : GestureHandler() {
     private const val DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE = true
     private const val DEFAULT_SHOULD_ACTIVATE_ON_START = false
     private const val DEFAULT_DISALLOW_INTERRUPTION = false
+    private const val DEFAULT_YIELDS_TO_CONTINUOUS_GESTURES = false
 
     private fun tryIntercept(view: View, event: MotionEvent) = view is ViewGroup && view.onInterceptTouchEvent(event)
 
@@ -252,6 +300,16 @@ class NativeViewGestureHandler : GestureHandler() {
      */
     fun shouldCancelRootViewGestureHandlerIfNecessary() = false
 
+    /**
+     * Called when the handler is being recorded by the orchestrator, before any pointer events
+     * are delivered. Returning `false` cancels the handler immediately.
+     *
+     * @param recorded handlers already recorded for the current touch
+     * @param handler the handler being recorded
+     */
+    fun shouldBeginWithRecordedHandlers(recorded: List<GestureHandler>, handler: NativeViewGestureHandler): Boolean =
+      true
+
     /**
      * Passes the event down to the underlying view using the correct method.
      */
@@ -285,11 +343,14 @@ class NativeViewGestureHandler : GestureHandler() {
       }
     }
 
-    // recognize alongside every handler besides RootViewGestureHandler, which is a private inner class
-    // of RNGestureHandlerRootHelper so no explicit type checks, but its tag is always negative
+    // recognize alongside every handler besides RootViewGestureHandler;
     // also if other handler is NativeViewGestureHandler then don't override the default implementation
-    override fun shouldRecognizeSimultaneously(handler: GestureHandler) =
-      handler.tag > 0 && handler !is NativeViewGestureHandler
+    override fun shouldRecognizeSimultaneously(handler: GestureHandler): Boolean? =
+      if (handler is NativeViewGestureHandler) {
+        null
+      } else {
+        handler !is RNGestureHandlerRootHelper.RootViewGestureHandler
+      }
 
     override fun wantsToHandleEventBeforeActivation() = true
 

package/android/src/main/java/com/swmansion/gesturehandler/core/OnJSResponderCancelListener.kt

@@ -0,0 +1,6 @@
+package com.swmansion.gesturehandler.core
+
+interface OnJSResponderCancelListener {
+  fun onCancelJSResponderRequested(handler: GestureHandler)
+  fun onCancelJSResponderReleased(handler: GestureHandler)
+}

package/android/src/main/java/com/swmansion/gesturehandler/core/PanGestureHandler.kt

@@ -13,6 +13,8 @@ import com.swmansion.gesturehandler.core.GestureUtils.getLastPointerY
 import com.swmansion.gesturehandler.react.events.eventbuilders.PanGestureHandlerEventDataBuilder
 
 class PanGestureHandler(context: Context?) : GestureHandler() {
+  override val isContinuous = true
+
   var velocityX = 0f
     private set
   var velocityY = 0f

package/android/src/main/java/com/swmansion/gesturehandler/core/PinchGestureHandler.kt

@@ -8,6 +8,8 @@ import com.swmansion.gesturehandler.react.events.eventbuilders.PinchGestureHandl
 import kotlin.math.abs
 
 class PinchGestureHandler : GestureHandler() {
+  override val isContinuous = true
+
   var scale = 0.0
     private set
   var velocity = 0.0
@@ -68,9 +70,17 @@ class PinchGestureHandler : GestureHandler() {
     }
 
     if (state == STATE_UNDETERMINED) {
-      initialize(event, sourceEvent)
-      begin()
+      when (sourceEvent.actionMasked) {
+        MotionEvent.ACTION_DOWN -> {
+          initialize(event, sourceEvent)
+        }
+
+        MotionEvent.ACTION_POINTER_DOWN -> {
+          begin()
+        }
+      }
     }
+
     scaleGestureDetector?.onTouchEvent(sourceEvent)
     scaleGestureDetector?.let {
       val point = transformPoint(PointF(it.focusX, it.focusY))
@@ -79,10 +89,10 @@ class PinchGestureHandler : GestureHandler() {
     }
 
     if (sourceEvent.actionMasked == MotionEvent.ACTION_UP) {
-      if (state == STATE_ACTIVE) {
-        end()
-      } else {
-        fail()
+      when (state) {
+        STATE_UNDETERMINED -> cancel()
+        STATE_ACTIVE -> end()
+        else -> fail()
       }
     }
   }

package/android/src/main/java/com/swmansion/gesturehandler/core/RotationGestureHandler.kt

@@ -8,6 +8,8 @@ import com.swmansion.gesturehandler.react.events.eventbuilders.RotationGestureHa
 import kotlin.math.abs
 
 class RotationGestureHandler : GestureHandler() {
+  override val isContinuous = true
+
   private var rotationGestureDetector: RotationGestureDetector? = null
   var rotation = 0.0
     private set
@@ -59,9 +61,17 @@ class RotationGestureHandler : GestureHandler() {
     }
 
     if (state == STATE_UNDETERMINED) {
-      initialize(event, sourceEvent)
-      begin()
+      when (sourceEvent.actionMasked) {
+        MotionEvent.ACTION_DOWN -> {
+          initialize(event, sourceEvent)
+        }
+
+        MotionEvent.ACTION_POINTER_DOWN -> {
+          begin()
+        }
+      }
     }
+
     rotationGestureDetector?.onTouchEvent(sourceEvent)
     rotationGestureDetector?.let {
       val point = transformPoint(PointF(it.anchorX, it.anchorY))
@@ -71,8 +81,11 @@ class RotationGestureHandler : GestureHandler() {
 
     // ACTION_UP is already handled in rotationGestureDetector.onTouchEvent (and effectively in onRotationEnd)
     // if more than one pointer was used
-    if (sourceEvent.actionMasked == MotionEvent.ACTION_UP && state == STATE_BEGAN) {
-      fail()
+    if (sourceEvent.actionMasked == MotionEvent.ACTION_UP) {
+      when (state) {
+        STATE_UNDETERMINED -> cancel()
+        STATE_BEGAN -> fail()
+      }
     }
   }
 

package/android/src/main/java/com/swmansion/gesturehandler/core/ViewConfigurationHelper.kt

@@ -5,6 +5,5 @@ import android.view.ViewGroup
 
 interface ViewConfigurationHelper {
   fun getPointerEventsConfigForView(view: View): PointerEventsConfig
-  fun getChildInDrawingOrderAtIndex(parent: ViewGroup, index: Int): View
   fun isViewClippingChildren(view: ViewGroup): Boolean
 }

package/android/src/main/java/com/swmansion/gesturehandler/react/Extensions.kt

@@ -1,6 +1,7 @@
 package com.swmansion.gesturehandler.react
 
 import android.content.Context
+import android.view.Display
 import android.view.MotionEvent
 import android.view.accessibility.AccessibilityManager
 import com.facebook.react.bridge.ReactContext
@@ -15,3 +16,23 @@ fun Context.isScreenReaderOn() =
 fun MotionEvent.isHoverAction(): Boolean = action == MotionEvent.ACTION_HOVER_MOVE ||
   action == MotionEvent.ACTION_HOVER_ENTER ||
   action == MotionEvent.ACTION_HOVER_EXIT
+
+val Display.minimumFrameTime: Float
+  get() {
+    val supportedModes = this.supportedModes
+    var maxRefreshRate = 0f
+
+    supportedModes.forEach { mode ->
+      if (mode.refreshRate > maxRefreshRate) {
+        maxRefreshRate = mode.refreshRate
+      }
+    }
+
+    val effectiveRefreshRate = when {
+      maxRefreshRate > 0f -> maxRefreshRate
+      refreshRate > 0f -> refreshRate
+      else -> 60f
+    }
+
+    return 1000.0f / effectiveRefreshRate
+  }