react-native-gesture-handler 3.0.0-beta.2 → 3.0.0-beta.4

package/ReanimatedDrawerLayout/package.json

@@ -1,5 +1,5 @@
 {
-  "main": "../lib/commonjs/components/ReanimatedDrawerLayout",
+  "main": "../lib/module/components/ReanimatedDrawerLayout",
   "module": "../lib/module/components/ReanimatedDrawerLayout",
   "react-native": "../src/components/ReanimatedDrawerLayout",
   "types": "../lib/typescript/components/ReanimatedDrawerLayout.d.ts"

package/ReanimatedSwipeable/package.json

@@ -1,5 +1,5 @@
 {
-  "main": "../lib/commonjs/components/ReanimatedSwipeable/",
+  "main": "../lib/module/components/ReanimatedSwipeable/",
   "module": "../lib/module/components/ReanimatedSwipeable/",
   "react-native": "../src/components/ReanimatedSwipeable/",
   "types": "../lib/typescript/components/ReanimatedSwipeable/"

package/android/src/main/java/com/swmansion/gesturehandler/RNGestureHandlerPackage.kt

@@ -11,7 +11,6 @@ import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
 import com.swmansion.gesturehandler.react.RNGestureHandlerButtonViewManager
-import com.swmansion.gesturehandler.react.RNGestureHandlerButtonWrapperViewManager
 import com.swmansion.gesturehandler.react.RNGestureHandlerDetectorViewManager
 import com.swmansion.gesturehandler.react.RNGestureHandlerModule
 import com.swmansion.gesturehandler.react.RNGestureHandlerRootViewManager
@@ -35,9 +34,6 @@ class RNGestureHandlerPackage :
       RNGestureHandlerDetectorViewManager.REACT_CLASS to ModuleSpec.viewManagerSpec {
         RNGestureHandlerDetectorViewManager()
       },
-      RNGestureHandlerButtonWrapperViewManager.REACT_CLASS to ModuleSpec.viewManagerSpec {
-        RNGestureHandlerButtonWrapperViewManager()
-      },
     )
   }
 
@@ -45,7 +41,6 @@ class RNGestureHandlerPackage :
     RNGestureHandlerRootViewManager(),
     RNGestureHandlerButtonViewManager(),
     RNGestureHandlerDetectorViewManager(),
-    RNGestureHandlerButtonWrapperViewManager(),
   )
 
   override fun getViewManagerNames(reactContext: ReactApplicationContext) = viewManagers.keys.toList()

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,27 +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
-    if (view is RNGestureHandlerDetectorView && (view as RNGestureHandlerDetectorView).isNotEmpty()) {
-      val detector = view as RNGestureHandlerDetectorView
-      val outPoint = PointF()
-      GestureHandlerOrchestrator.transformPointToChildViewCoords(
-        adaptedTransformedEvent.x,
-        adaptedTransformedEvent.y,
-        detector,
-        detector.getChildAt(0),
-        outPoint,
-      )
-      x = outPoint.x
-      y = outPoint.y
-      isWithinBounds = isWithinBounds(detector.getChildAt(0), x, y)
-    } 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)) {
@@ -629,11 +641,22 @@ open class GestureHandler {
     onStateChange(newState, oldState)
   }
 
-  fun wantsEvent(event: MotionEvent): Boolean = isEnabled &&
-    state != STATE_FAILED &&
-    state != STATE_CANCELLED &&
-    state != STATE_END &&
-    isTrackingPointer(event.getPointerId(event.actionIndex))
+  fun wantsEvent(event: MotionEvent): Boolean {
+    if (!isEnabled || state == STATE_FAILED || state == STATE_CANCELLED || state == STATE_END) {
+      return false
+    }
+
+    if (event.actionMasked == MotionEvent.ACTION_MOVE) {
+      for (i in 0 until event.pointerCount) {
+        if (isTrackingPointer(event.getPointerId(i))) {
+          return true
+        }
+      }
+      return false
+    } else {
+      return isTrackingPointer(event.getPointerId(event.actionIndex))
+    }
+  }
 
   open fun shouldRequireToWaitForFailure(handler: GestureHandler): Boolean {
     if (handler === this) {
@@ -667,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)
@@ -844,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
@@ -935,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>
@@ -957,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) {
@@ -1020,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) {
@@ -287,7 +300,7 @@ class GestureHandlerOrchestrator(
   }
 
   private fun deliverEventToGestureHandler(handler: GestureHandler, sourceEvent: MotionEvent) {
-    if (!isViewAttachedUnderWrapper(handler.view)) {
+    if (!isViewAttachedUnderWrapper(handler.view ?: handler.hostDetectorView)) {
       handler.cancel()
       return
     }
@@ -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)
@@ -448,11 +461,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 +624,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 +677,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) {
@@ -123,6 +151,10 @@ class NativeViewGestureHandler : GestureHandler() {
 
       hook.afterGestureEnd(event)
     } else if (state == STATE_UNDETERMINED || state == STATE_BEGAN) {
+      if (state != STATE_BEGAN && hook.canBegin(event)) {
+        begin()
+      }
+
       when {
         shouldActivateOnStart -> {
           tryIntercept(view, event)
@@ -138,12 +170,6 @@ class NativeViewGestureHandler : GestureHandler() {
         hook.wantsToHandleEventBeforeActivation() -> {
           hook.handleEventBeforeActivation(event)
         }
-
-        state != STATE_BEGAN -> {
-          if (hook.canBegin(event)) {
-            begin()
-          }
-        }
       }
     } else if (state == STATE_ACTIVE) {
       hook.sendTouchEvent(view, event)
@@ -165,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
@@ -183,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)
@@ -190,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"
     }
   }
 
@@ -197,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)
 
@@ -254,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.
      */
@@ -287,11 +343,10 @@ 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
+      handler !is RNGestureHandlerRootHelper.RootViewGestureHandler && handler !is NativeViewGestureHandler
 
     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
@@ -35,7 +37,11 @@ class RotationGestureHandler : GestureHandler() {
     override fun onRotationBegin(detector: RotationGestureDetector) = true
 
     override fun onRotationEnd(detector: RotationGestureDetector) {
-      end()
+      if (state == STATE_ACTIVE) {
+        end()
+      } else {
+        fail()
+      }
     }
   }
 
@@ -55,20 +61,30 @@ 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))
       anchorX = point.x
       anchorY = point.y
     }
+
+    // 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) {
-      if (state == STATE_ACTIVE) {
-        end()
-      } else {
-        fail()
+      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
 }