react-native-gesture-handler 2.32.0 → 2.33.0

package/android/build.gradle

@@ -2,17 +2,18 @@ import groovy.json.JsonSlurper
 import com.android.build.gradle.tasks.ExternalNativeBuildJsonTask
 
 buildscript {
-    def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['RNGH_kotlinVersion']
-
     repositories {
         mavenCentral()
         google()
     }
 
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version")
-        classpath("com.android.tools.build:gradle:8.10.1")
-        classpath("com.diffplug.spotless:spotless-plugin-gradle:7.0.4")
+        if (project == rootProject) {
+            def kotlin_version = project.properties['RNGH_kotlinVersion']
+            classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version")
+            classpath("com.android.tools.build:gradle:8.10.1")
+            classpath("com.diffplug.spotless:spotless-plugin-gradle:7.0.4")
+        }
     }
 }
 
@@ -62,7 +63,22 @@ if (isNewArchitectureEnabled()) {
 }
 
 apply plugin: 'com.android.library'
-apply plugin: 'kotlin-android'
+
+def shouldEnableAgpFallback() {
+    def agpMajorVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')[0].toInteger()
+    if (agpMajorVersion <= 8) {
+        return true
+    }
+
+    def propertyVal = providers.gradleProperty("android.builtInKotlin").orNull
+    def isBuiltInKotlinEnabled = propertyVal != null ? propertyVal.toBoolean() : true
+
+    return !isBuiltInKotlinEnabled
+}
+
+if (shouldEnableAgpFallback()) {
+    apply plugin: 'kotlin-android'
+}
 
 if (project == rootProject) {
     apply from: "spotless.gradle"
@@ -190,17 +206,17 @@ android {
     }
 
     sourceSets.main {
-        java {
+        kotlin {
             if (shouldUseCommonInterfaceFromReanimated()) {
-                srcDirs += 'reanimated/src/main/java'
+                directories.add('reanimated/src/main/java')
             } else {
-                srcDirs += 'noreanimated/src/main/java'
+                directories.add('noreanimated/src/main/java')
             }
 
             if (shouldUseCommonInterfaceFromRNSVG()) {
-                srcDirs += 'svg/src/main/java'
+                directories.add('svg/src/main/java')
             } else {
-                srcDirs += 'nosvg/src/main/java'
+                directories.add('nosvg/src/main/java')
             }
 
             if (isNewArchitectureEnabled()) {

package/android/gradle.properties

@@ -16,4 +16,4 @@ org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=512m -XX:+HeapDumpOnOutOfMemor
 # This option should only be used with decoupled projects. More details, visit
 # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
 # org.gradle.parallel=true
-RNGH_kotlinVersion=2.0.21
+RNGH_kotlinVersion=2.2.0

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

@@ -88,7 +88,7 @@ class FlingGestureHandler : GestureHandler() {
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
-    if (!shouldActivateWithMouse(sourceEvent)) {
+    if (shouldSkipEvent(sourceEvent)) {
       return
     }
 

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

@@ -4,7 +4,6 @@ import android.app.Activity
 import android.content.Context
 import android.content.ContextWrapper
 import android.graphics.PointF
-import android.os.Build
 import android.view.MotionEvent
 import android.view.MotionEvent.PointerCoords
 import android.view.MotionEvent.PointerProperties
@@ -426,10 +425,15 @@ open class GestureHandler {
   }
 
   private fun dispatchTouchUpEvent(event: MotionEvent, sourceEvent: MotionEvent) {
+    val pointerId = event.getPointerId(event.actionIndex)
+
+    if (trackedPointers[pointerId] == null) {
+      return
+    }
+
     extractAllPointersData()
     changedTouchesPayload = null
     touchEventType = RNGestureHandlerTouchEvent.EVENT_TOUCH_UP
-    val pointerId = event.getPointerId(event.actionIndex)
     val offsetX = sourceEvent.rawX - sourceEvent.x
     val offsetY = sourceEvent.rawY - sourceEvent.y
 
@@ -754,44 +758,38 @@ open class GestureHandler {
     return clickedButton and mouseButton != 0
   }
 
-  protected fun shouldActivateWithMouse(sourceEvent: MotionEvent): Boolean {
-    // While using mouse, we get both sets of events, for example ACTION_DOWN and ACTION_BUTTON_PRESS. That's why we want to take actions to only one of them.
-    // On API >= 23, we will use events with infix BUTTON, otherwise we use standard action events (like ACTION_DOWN).
+  // Decides whether the gesture should ignore this event. While using a mouse we receive both the
+  // touch-compatible stream (ACTION_DOWN/UP/...) and the BUTTON_* events, so we act on only the
+  // latter, and we drop events coming from a button other than the configured `mouseButton`.
+  // Non-mouse input is never skipped here.
+  protected fun shouldSkipEvent(sourceEvent: MotionEvent): Boolean {
+    if (sourceEvent.getToolType(0) != MotionEvent.TOOL_TYPE_MOUSE) {
+      return false
+    }
 
     with(sourceEvent) {
-      // To use actionButton, we need API >= 23.
-      if (getToolType(0) == MotionEvent.TOOL_TYPE_MOUSE &&
-        Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
+      // While using mouse, we want to ignore default events for touch.
+      if (actionMasked == MotionEvent.ACTION_DOWN ||
+        actionMasked == MotionEvent.ACTION_UP ||
+        actionMasked == MotionEvent.ACTION_POINTER_UP ||
+        actionMasked == MotionEvent.ACTION_POINTER_DOWN
       ) {
-        // While using mouse, we want to ignore default events for touch.
-        if (action == MotionEvent.ACTION_DOWN ||
-          action == MotionEvent.ACTION_UP ||
-          action == MotionEvent.ACTION_POINTER_UP ||
-          action == MotionEvent.ACTION_POINTER_DOWN
-        ) {
-          return@shouldActivateWithMouse false
-        }
+        return@shouldSkipEvent true
+      }
 
-        // We don't want to do anything if wrong button was clicked. If we received event for BUTTON, we have to use actionButton to get which one was clicked.
-        if (action != MotionEvent.ACTION_MOVE && !isButtonInConfig(actionButton)) {
-          return@shouldActivateWithMouse false
-        }
+      // Skip events from a button other than the configured one. For BUTTON_* events the clicked
+      // button is read from `actionButton`.
+      if (actionMasked != MotionEvent.ACTION_MOVE && !isButtonInConfig(actionButton)) {
+        return@shouldSkipEvent true
+      }
 
-        // When we receive ACTION_MOVE, we have to check buttonState field.
-        if (action == MotionEvent.ACTION_MOVE && !isButtonInConfig(buttonState)) {
-          return@shouldActivateWithMouse false
-        }
-      } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
-        // We do not fully support mouse below API 23, so we will ignore BUTTON events.
-        if (action == MotionEvent.ACTION_BUTTON_PRESS ||
-          action == MotionEvent.ACTION_BUTTON_RELEASE
-        ) {
-          return@shouldActivateWithMouse false
-        }
+      // For ACTION_MOVE the pressed button is read from `buttonState`.
+      if (actionMasked == MotionEvent.ACTION_MOVE && !isButtonInConfig(buttonState)) {
+        return@shouldSkipEvent true
       }
     }
 
-    return true
+    return false
   }
 
   /**
@@ -984,7 +982,8 @@ open class GestureHandler {
     const val POINTER_TYPE_TOUCH = 0
     const val POINTER_TYPE_STYLUS = 1
     const val POINTER_TYPE_MOUSE = 2
-    const val POINTER_TYPE_OTHER = 3
+    const val POINTER_TYPE_KEY = 3
+    const val POINTER_TYPE_OTHER = 4
     private const val MAX_POINTERS_COUNT = 12
     private lateinit var pointerProps: Array<PointerProperties?>
     private lateinit var pointerCoords: Array<PointerCoords?>

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

@@ -2,6 +2,7 @@ package com.swmansion.gesturehandler.core
 
 import android.graphics.Matrix
 import android.graphics.PointF
+import android.util.SparseArray
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
@@ -26,7 +27,20 @@ class GestureHandlerOrchestrator(
   var minimumAlphaForTraversal = DEFAULT_MIN_ALPHA_FOR_TRAVERSAL
   private val gestureHandlers = arrayListOf<GestureHandler>()
   private val awaitingHandlers = arrayListOf<GestureHandler>()
-  private val preparedHandlers = arrayListOf<GestureHandler>()
+
+  // Pool of reusable lists for snapshotting `gestureHandlers` during event delivery.
+  private val handlerListPool = ArrayDeque<ArrayList<GestureHandler>>()
+
+  private fun obtainHandlerList() = handlerListPool.pollLast() ?: ArrayList<GestureHandler>()
+
+  private fun recycleHandlerList(list: ArrayList<GestureHandler>) {
+    list.clear()
+    handlerListPool.addLast(list)
+  }
+
+  // Used by `cancelTouchesInInterceptedViews`.
+  private val viewsToCancel = arrayListOf<View>()
+  private val pointerDownPoints = SparseArray<PointF>()
 
   // In `onHandlerStateChange` method we iterate through `awaitingHandlers`, but calling `tryActivate` may modify this list.
   // To avoid `ConcurrentModificationException` we iterate through copy. There is one more problem though - if handler was
@@ -46,6 +60,7 @@ class GestureHandlerOrchestrator(
   fun onTouchEvent(event: MotionEvent): Boolean {
     isHandlingTouch = true
     val action = event.actionMasked
+    trackPointerDownPoints(event)
     if (action == MotionEvent.ACTION_DOWN ||
       action == MotionEvent.ACTION_POINTER_DOWN ||
       action == MotionEvent.ACTION_HOVER_MOVE
@@ -105,7 +120,7 @@ class GestureHandlerOrchestrator(
 
   private fun shouldBeCancelledByActiveHandler(handler: GestureHandler) = gestureHandlers.any {
     handler.hasCommonPointers(it) &&
-      it.state == GestureHandler.STATE_ACTIVE &&
+      it.isActive &&
       !canRunSimultaneously(handler, it) &&
       handler.isDescendantOf(it)
   }
@@ -141,6 +156,13 @@ class GestureHandlerOrchestrator(
   /*package*/
   fun onHandlerStateChange(handler: GestureHandler, newState: Int, prevState: Int) {
     handlingChangeSemaphore += 1
+
+    if (handler.isAwaiting &&
+      (newState == GestureHandler.STATE_CANCELLED || newState == GestureHandler.STATE_FAILED)
+    ) {
+      handler.isAwaiting = false
+    }
+
     if (isFinished(newState)) {
       // We have to loop through copy in order to avoid modifying collection
       // while iterating over its elements
@@ -252,20 +274,24 @@ class GestureHandlerOrchestrator(
   }
 
   private fun deliverEventToGestureHandlers(event: MotionEvent) {
-    // Copy handlers to "prepared handlers" array, because the list of active handlers can change
-    // as a result of state updates
-    preparedHandlers.clear()
-    preparedHandlers.addAll(gestureHandlers)
+    // Snapshot handlers into a pooled list, because the list of active handlers can change
+    // as a result of state updates (and delivery can be re-entrant).
+    val handlersToProcess = obtainHandlerList()
+    handlersToProcess.addAll(gestureHandlers)
 
     // We want to deliver events to active handlers first in order of their activation (handlers
     // that activated first will first get event delivered). Otherwise we deliver events in the
     // order in which handlers has been added ("most direct" children goes first). Therefore we rely
     // on Arrays.sort providing a stable sort (as children are registered in order in which they
     // should be tested)
-    preparedHandlers.sortWith(handlersComparator)
+    handlersToProcess.sortWith(handlersComparator)
 
-    for (handler in preparedHandlers) {
-      deliverEventToGestureHandler(handler, event)
+    try {
+      for (handler in handlersToProcess) {
+        deliverEventToGestureHandler(handler, event)
+      }
+    } finally {
+      recycleHandlerList(handlersToProcess)
     }
   }
 
@@ -276,12 +302,9 @@ class GestureHandlerOrchestrator(
       handler.cancel()
     }
 
-    // Copy handlers to "prepared handlers" array, because the list of active handlers can change
+    // Iterate over a copy, because the list of active handlers can change
     // as a result of state updates
-    preparedHandlers.clear()
-    preparedHandlers.addAll(gestureHandlers)
-
-    for (handler in gestureHandlers.asReversed()) {
+    for (handler in gestureHandlers.reversed()) {
       handler.cancel()
     }
   }
@@ -314,7 +337,7 @@ class GestureHandlerOrchestrator(
     if (!handler.isAwaiting || action != MotionEvent.ACTION_MOVE) {
       val isFirstEvent = handler.state == 0
       handler.handle(event, sourceEvent)
-      if (handler.isActive) {
+      if (handler.state == GestureHandler.STATE_ACTIVE && handler.isActive) {
         // After handler is done waiting for other one to fail its progress should be
         // reset, otherwise there may be a visible jump in values sent by the handler.
         // When handler is waiting it's already activated but the `isAwaiting` flag
@@ -622,6 +645,112 @@ class GestureHandlerOrchestrator(
     return false
   }
 
+  private fun trackPointerDownPoints(event: MotionEvent) {
+    val index = event.actionIndex
+    when (event.actionMasked) {
+      MotionEvent.ACTION_DOWN, MotionEvent.ACTION_POINTER_DOWN ->
+        pointerDownPoints.put(event.getPointerId(index), PointF(event.getX(index), event.getY(index)))
+      MotionEvent.ACTION_POINTER_UP ->
+        pointerDownPoints.remove(event.getPointerId(index))
+      MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL ->
+        pointerDownPoints.clear()
+    }
+  }
+
+  fun cancelTouchesInInterceptedViews(event: MotionEvent) {
+    viewsToCancel.clear()
+    for (i in 0 until pointerDownPoints.size()) {
+      val point = pointerDownPoints.valueAt(i)
+      tempCoords[0] = point.x
+      tempCoords[1] = point.y
+      collectViewsAtPoint(wrapperView, tempCoords, viewsToCancel)
+    }
+
+    if (viewsToCancel.isEmpty()) {
+      return
+    }
+
+    val activeHandlers = gestureHandlers.filter { it.isActive }
+    val cancelEvent = MotionEvent.obtain(event).apply { action = MotionEvent.ACTION_CANCEL }
+
+    for (view in viewsToCancel) {
+      if (view === wrapperView || isViewDrivenByActiveNativeGesture(view, activeHandlers)) {
+        continue
+      }
+      view.onTouchEvent(cancelEvent)
+    }
+
+    cancelEvent.recycle()
+    viewsToCancel.clear()
+  }
+
+  // Whether the view's touch is still owned by a NativeViewGestureHandler that survived arbitration.
+  // Only those are fed through `onTouchEvent`, so only those break if cancelled. Other handlers are
+  // orchestrator-driven and unaffected.
+  private fun isViewDrivenByActiveNativeGesture(view: View, activeHandlers: List<GestureHandler>) =
+    handlerRegistry.getHandlersForView(view)?.let { handlers ->
+      synchronized(handlers) {
+        handlers.any { nativeGestureSurvivesArbitration(it, activeHandlers) }
+      }
+    } ?: false
+
+  // A native handler survives arbitration if it is active, or it does not conflict with any active handler.
+  private fun nativeGestureSurvivesArbitration(handler: GestureHandler, activeHandlers: List<GestureHandler>) =
+    handler is NativeViewGestureHandler &&
+      (handler.isActive || activeHandlers.none { shouldHandlerBeCancelledBy(handler, it) })
+
+  // Collects the view path under the point (topmost child first, like touch dispatch), leaf to root.
+  private fun collectViewsAtPoint(view: View, coords: FloatArray, out: MutableList<View>): Boolean {
+    if (shouldIgnoreSubtreeIfGestureHandlerRootView(view)) {
+      // A nested active root view manages its own subtree (and its own interception cancellation).
+      return false
+    }
+
+    val pointerEvents = viewConfigHelper.getPointerEventsConfigForView(view)
+    if (pointerEvents == PointerEventsConfig.NONE) {
+      return false
+    }
+
+    var found = false
+    if (view is ViewGroup && pointerEvents != PointerEventsConfig.BOX_ONLY) {
+      for (i in view.childCount - 1 downTo 0) {
+        val child = view.getChildAt(i)
+        if (!canReceiveEvents(child)) {
+          continue
+        }
+        val childPoint = tempPoint
+        transformPointToChildViewCoords(coords[0], coords[1], view, child, childPoint)
+        if (isClipping(child) && !isTransformedTouchPointInView(childPoint.x, childPoint.y, child)) {
+          continue
+        }
+        val restoreX = coords[0]
+        val restoreY = coords[1]
+        coords[0] = childPoint.x
+        coords[1] = childPoint.y
+        found = collectViewsAtPoint(child, coords, out)
+        coords[0] = restoreX
+        coords[1] = restoreY
+
+        if (found) {
+          break
+        }
+      }
+    }
+
+    // BOX_NONE views can't be the target themselves, only their children can
+    val selfIsTarget = pointerEvents != PointerEventsConfig.BOX_NONE &&
+      isTransformedTouchPointInView(coords[0], coords[1], view)
+
+    if (found || selfIsTarget) {
+      // `out` may already contain this view when several pointers share part of their path.
+      if (!out.contains(view)) {
+        out.add(view)
+      }
+      return true
+    }
+    return false
+  }
+
   private fun traverseWithPointerEvents(view: View, coords: FloatArray, pointerId: Int, event: MotionEvent): Boolean =
     if (shouldIgnoreSubtreeIfGestureHandlerRootView(view)) {
       // When we encounter another active root view while traversing the view hierarchy, we want

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

@@ -29,13 +29,14 @@ class LongPressGestureHandler(context: Context) : GestureHandler() {
     val systemDefaultMaxDist = DEFAULT_MAX_DIST_DP * context.resources.displayMetrics.density
     defaultMaxDist = systemDefaultMaxDist
     maxDist = defaultMaxDist
-    numberOfPointersRequired = 1
+    numberOfPointersRequired = DEFAULT_NUMBER_OF_POINTERS_REQUIRED
   }
 
   override fun resetConfig() {
     super.resetConfig()
     minDurationMs = DEFAULT_MIN_DURATION_MS
     maxDist = defaultMaxDist
+    numberOfPointersRequired = DEFAULT_NUMBER_OF_POINTERS_REQUIRED
     shouldCancelWhenOutside = DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE
   }
 
@@ -66,7 +67,7 @@ class LongPressGestureHandler(context: Context) : GestureHandler() {
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
-    if (!shouldActivateWithMouse(sourceEvent)) {
+    if (shouldSkipEvent(sourceEvent)) {
       return
     }
 
@@ -99,7 +100,8 @@ class LongPressGestureHandler(context: Context) : GestureHandler() {
       currentPointers == numberOfPointersRequired &&
       (
         sourceEvent.actionMasked == MotionEvent.ACTION_DOWN ||
-          sourceEvent.actionMasked == MotionEvent.ACTION_POINTER_DOWN
+          sourceEvent.actionMasked == MotionEvent.ACTION_POINTER_DOWN ||
+          sourceEvent.actionMasked == MotionEvent.ACTION_BUTTON_PRESS
         )
     ) {
       handler = Handler(Looper.getMainLooper())
@@ -207,5 +209,6 @@ class LongPressGestureHandler(context: Context) : GestureHandler() {
     private const val DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE = true
     private const val DEFAULT_MIN_DURATION_MS: Long = 500
     private const val DEFAULT_MAX_DIST_DP = 10f
+    private const val DEFAULT_NUMBER_OF_POINTERS_REQUIRED = 1
   }
 }

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

@@ -109,6 +109,9 @@ class NativeViewGestureHandler : GestureHandler() {
         cancel()
       } else {
         hook.sendTouchEvent(view, event)
+        if (shouldStopNestedScroll()) {
+          view.stopNestedScroll()
+        }
 
         if ((state == STATE_UNDETERMINED || state == STATE_BEGAN) && hook.canActivate(view)) {
           activate()
@@ -156,9 +159,19 @@ class NativeViewGestureHandler : GestureHandler() {
       action = MotionEvent.ACTION_CANCEL
     }
     hook.sendTouchEvent(view, event)
+    if (shouldStopNestedScroll()) {
+      view?.stopNestedScroll()
+    }
     event.recycle()
   }
 
+  // Once the handler is active, it delivers touches straight to the view's `onTouchEvent`. Normally
+  // touches arrive through `View.dispatchTouchEvent`, which also ends the nested scroll when the finger
+  // goes up. Because we skip it, the nested scroll stays open and the parent never finds out that the
+  // gesture is over - e.g. SwipeRefreshLayout never fires refresh (#4485). While the handler is not
+  // active, the view still receives touches the regular way, so Android takes care of it.
+  private fun shouldStopNestedScroll() = state == STATE_ACTIVE && hook.shouldStopNestedScroll()
+
   override fun onCancel() = dispatchCancelEventToView()
 
   override fun onFail() = dispatchCancelEventToView()
@@ -211,6 +224,12 @@ class NativeViewGestureHandler : GestureHandler() {
      */
     fun canBegin(event: MotionEvent) = true
 
+    /**
+     * Whether the view's nested scroll should be stopped when the active gesture ends. Touches
+     * are fed through `onTouchEvent`, so `View.dispatchTouchEvent` never gets to do it.
+     */
+    fun shouldStopNestedScroll() = false
+
     /**
      * Checks whether handler can activate. Used by TextViewHook.
      */
@@ -336,6 +355,10 @@ class NativeViewGestureHandler : GestureHandler() {
 
   private class ScrollViewHook : NativeViewGestureHandlerHook {
     override fun shouldCancelRootViewGestureHandlerIfNecessary() = true
+
+    // ScrollView starts a nested scroll on DOWN but never stops it itself. Without this the
+    // parent's `onStopNestedScroll` never runs, e.g. SwipeRefreshLayout never triggers refresh.
+    override fun shouldStopNestedScroll() = true
   }
 
   private class ReactViewGroupHook : NativeViewGestureHandlerHook {

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

@@ -11,6 +11,7 @@ import com.facebook.react.uimanager.PixelUtil
 import com.swmansion.gesturehandler.core.GestureUtils.getLastPointerX
 import com.swmansion.gesturehandler.core.GestureUtils.getLastPointerY
 import com.swmansion.gesturehandler.react.eventbuilders.PanGestureHandlerEventDataBuilder
+import kotlin.math.abs
 
 class PanGestureHandler(context: Context?) : GestureHandler() {
   var velocityX = 0f
@@ -113,15 +114,11 @@ class PanGestureHandler(context: Context?) : GestureHandler() {
       return true
     }
     val vx = velocityX
-    if (minVelocityX != MIN_VALUE_IGNORE &&
-      (minVelocityX < 0 && vx <= minVelocityX || minVelocityX in 0.0f..vx)
-    ) {
+    if (minVelocityX != MIN_VALUE_IGNORE && abs(vx) >= abs(minVelocityX)) {
       return true
     }
     val vy = velocityY
-    if (minVelocityY != MIN_VALUE_IGNORE &&
-      (minVelocityY < 0 && vx <= minVelocityY || minVelocityY in 0.0f..vx)
-    ) {
+    if (minVelocityY != MIN_VALUE_IGNORE && abs(vy) >= abs(minVelocityY)) {
       return true
     }
     val velocitySq = vx * vx + vy * vy
@@ -149,7 +146,7 @@ class PanGestureHandler(context: Context?) : GestureHandler() {
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
-    if (!shouldActivateWithMouse(sourceEvent)) {
+    if (shouldSkipEvent(sourceEvent)) {
       return
     }
 

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

@@ -82,7 +82,7 @@ class TapGestureHandler : GestureHandler() {
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
-    if (!shouldActivateWithMouse(sourceEvent)) {
+    if (shouldSkipEvent(sourceEvent)) {
       return
     }
 

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

@@ -19,3 +19,6 @@ fun Context.isScreenReaderOn() =
 fun MotionEvent.isHoverAction(): Boolean = action == MotionEvent.ACTION_HOVER_MOVE ||
   action == MotionEvent.ACTION_HOVER_ENTER ||
   action == MotionEvent.ACTION_HOVER_EXIT
+
+fun MotionEvent.isButtonAction(): Boolean = actionMasked == MotionEvent.ACTION_BUTTON_PRESS ||
+  actionMasked == MotionEvent.ACTION_BUTTON_RELEASE

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

@@ -554,6 +554,8 @@ class RNGestureHandlerButtonViewManager :
       // by default Viewgroup would pass hotspot change events
     }
 
+    override fun shouldDelayChildPressedState(): Boolean = false
+
     private fun findGestureHandlerRootView(): RNGestureHandlerRootView? {
       var parent: ViewParent? = this.parent
       var gestureHandlerRootView: RNGestureHandlerRootView? = null

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

@@ -19,6 +19,7 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:
   private val jsGestureHandler: GestureHandler?
   val rootView: ViewGroup
   private var shouldIntercept = false
+  private var wasIntercepting = false
   private var passingTouch = false
 
   init {
@@ -118,6 +119,14 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:
     passingTouch = true
     orchestrator!!.onTouchEvent(event)
     passingTouch = false
+
+    // On the transition into interception, cancel the native views the pointers landed on - the
+    // framework's ACTION_CANCEL never reaches them since RNGH ignores `onInterceptTouchEvent`
+    if (shouldIntercept && !wasIntercepting) {
+      orchestrator!!.cancelTouchesInInterceptedViews(event)
+    }
+    wasIntercepting = shouldIntercept
+
     return shouldIntercept
   }
 

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

@@ -40,12 +40,14 @@ class RNGestureHandlerRootView(context: Context?) : ReactViewGroup(context) {
     super.dispatchTouchEvent(event)
   }
 
-  override fun dispatchGenericMotionEvent(ev: MotionEvent) =
-    if (rootViewEnabled && ev.isHoverAction() && rootHelper!!.dispatchTouchEvent(ev)) {
-      true
-    } else {
-      super.dispatchGenericMotionEvent(ev)
-    }
+  override fun dispatchGenericMotionEvent(ev: MotionEvent) = if (rootViewEnabled &&
+    (ev.isHoverAction() || ev.isButtonAction()) &&
+    rootHelper!!.dispatchTouchEvent(ev)
+  ) {
+    true
+  } else {
+    super.dispatchGenericMotionEvent(ev)
+  }
 
   override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
     if (rootViewEnabled) {

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

@@ -54,13 +54,8 @@ class RNGestureHandlerTouchEvent private constructor() : Event<RNGestureHandlerT
       putInt("eventType", handler.touchEventType)
       putInt("pointerType", handler.pointerType)
 
-      handler.consumeChangedTouchesPayload()?.let {
-        putArray("changedTouches", it)
-      }
-
-      handler.consumeAllTouchesPayload()?.let {
-        putArray("allTouches", it)
-      }
+      putArray("changedTouches", handler.consumeChangedTouchesPayload() ?: Arguments.createArray())
+      putArray("allTouches", handler.consumeAllTouchesPayload() ?: Arguments.createArray())
 
       if (handler.isAwaiting && handler.state == GestureHandler.STATE_ACTIVE) {
         putInt("state", GestureHandler.STATE_BEGAN)