react-native-gesture-handler 2.13.4 → 2.14.1

package/android/build.gradle

@@ -139,6 +139,7 @@ android {
                     cppFlags "-O2", "-frtti", "-fexceptions", "-Wall", "-Werror", "-std=c++17", "-DANDROID"
                     arguments "-DAPP_BUILD_DIR=${appProject.buildDir}",
                         "-DREACT_NATIVE_DIR=${REACT_NATIVE_DIR}",
+                        "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
                         "-DANDROID_STL=c++_shared"
                     abiFilters (*reactNativeArchitectures())
                 }
@@ -179,11 +180,11 @@ android {
             }
 
             if (isNewArchitectureEnabled()) {
-                srcDirs += 'src/fabric/java'
+                srcDirs += 'fabric/src/main/java'
             } else {
                 // this folder also includes files from codegen so the library can compile with
                 // codegen turned off
-                srcDirs += 'src/paper/java'
+                srcDirs += 'paper/src/main/java'
             }
         }
     }

package/android/gradle.properties

@@ -9,8 +9,8 @@
 
 # Specifies the JVM arguments used for the daemon process.
 # The setting is particularly useful for tweaking memory settings.
-# Default value: -Xmx10248m -XX:MaxPermSize=256m
-org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+# Default value: -Xmx10248m -XX:MaxMetaspaceSize=256m
+org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
 
 # When configured, Gradle will run in incubating parallel mode.
 # This option should only be used with decoupled projects. More details, visit

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

@@ -19,13 +19,9 @@ class GestureHandlerOrchestrator(
    * traversing view hierarchy and looking for gesture handlers.
    */
   var minimumAlphaForTraversal = DEFAULT_MIN_ALPHA_FOR_TRAVERSAL
-
-  private val gestureHandlers = arrayOfNulls<GestureHandler<*>?>(SIMULTANEOUS_GESTURE_HANDLER_LIMIT)
-  private val awaitingHandlers = arrayOfNulls<GestureHandler<*>?>(SIMULTANEOUS_GESTURE_HANDLER_LIMIT)
-  private val preparedHandlers = arrayOfNulls<GestureHandler<*>?>(SIMULTANEOUS_GESTURE_HANDLER_LIMIT)
-  private val handlersToCancel = arrayOfNulls<GestureHandler<*>?>(SIMULTANEOUS_GESTURE_HANDLER_LIMIT)
-  private var gestureHandlersCount = 0
-  private var awaitingHandlersCount = 0
+  private val gestureHandlers = arrayListOf<GestureHandler<*>>()
+  private val awaitingHandlers = arrayListOf<GestureHandler<*>>()
+  private val preparedHandlers = arrayListOf<GestureHandler<*>>()
   private var isHandlingTouch = false
   private var handlingChangeSemaphore = 0
   private var finishedHandlersCleanupScheduled = false
@@ -60,23 +56,9 @@ class GestureHandlerOrchestrator(
     }
   }
 
-  private inline fun compactHandlersIf(handlers: Array<GestureHandler<*>?>, count: Int, predicate: (handler: GestureHandler<*>?) -> Boolean): Int {
-    var out = 0
-    for (i in 0 until count) {
-      if (predicate(handlers[i])) {
-        handlers[out++] = handlers[i]
-      }
-    }
-    return out
-  }
-
   private fun cleanupFinishedHandlers() {
-    var shouldCleanEmptyCells = false
-    for (i in gestureHandlersCount - 1 downTo 0) {
-      val handler = gestureHandlers[i]!!
+    for (handler in gestureHandlers.asReversed()) {
       if (isFinished(handler.state) && !handler.isAwaiting) {
-        gestureHandlers[i] = null
-        shouldCleanEmptyCells = true
         handler.reset()
         handler.apply {
           isActive = false
@@ -85,17 +67,14 @@ class GestureHandlerOrchestrator(
         }
       }
     }
-    if (shouldCleanEmptyCells) {
-      gestureHandlersCount = compactHandlersIf(gestureHandlers, gestureHandlersCount) { handler ->
-        handler != null
-      }
-    }
+
+    gestureHandlers.removeAll { isFinished(it.state) && !it.isAwaiting }
+
     finishedHandlersCleanupScheduled = false
   }
 
   private fun hasOtherHandlerToWaitFor(handler: GestureHandler<*>): Boolean {
-    for (i in 0 until gestureHandlersCount) {
-      val otherHandler = gestureHandlers[i]!!
+    for (otherHandler in gestureHandlers) {
       if (!isFinished(otherHandler.state) && shouldHandlerWaitForOther(handler, otherHandler)) {
         return true
       }
@@ -115,9 +94,7 @@ class GestureHandlerOrchestrator(
   }
 
   private fun cleanupAwaitingHandlers() {
-    awaitingHandlersCount = compactHandlersIf(awaitingHandlers, awaitingHandlersCount) { handler ->
-      handler!!.isAwaiting
-    }
+    awaitingHandlers.removeAll { !it.isAwaiting }
   }
 
   /*package*/
@@ -125,9 +102,8 @@ class GestureHandlerOrchestrator(
     handlingChangeSemaphore += 1
     if (isFinished(newState)) {
       // if there were handlers awaiting completion of this handler, we can trigger active state
-      for (i in 0 until awaitingHandlersCount) {
-        val otherHandler = awaitingHandlers[i]
-        if (shouldHandlerWaitForOther(otherHandler!!, handler)) {
+      for (otherHandler in awaitingHandlers) {
+        if (shouldHandlerWaitForOther(otherHandler, handler)) {
           if (newState == GestureHandler.STATE_END) {
             // gesture has ended, we need to kill the awaiting handler
             otherHandler.cancel()
@@ -182,21 +158,15 @@ class GestureHandlerOrchestrator(
       shouldResetProgress = true
       activationIndex = this@GestureHandlerOrchestrator.activationIndex++
     }
-    var toCancelCount = 0
-    // Cancel all handlers that are required to be cancel upon current handler's activation
-    for (i in 0 until gestureHandlersCount) {
-      val otherHandler = gestureHandlers[i]!!
+
+    for (otherHandler in gestureHandlers.asReversed()) {
       if (shouldHandlerBeCancelledBy(otherHandler, handler)) {
-        handlersToCancel[toCancelCount++] = otherHandler
+        otherHandler.cancel()
       }
     }
-    for (i in toCancelCount - 1 downTo 0) {
-      handlersToCancel[i]!!.cancel()
-    }
 
     // Clear all awaiting handlers waiting for the current handler to fail
-    for (i in awaitingHandlersCount - 1 downTo 0) {
-      val otherHandler = awaitingHandlers[i]!!
+    for (otherHandler in awaitingHandlers.reversed()) {
       if (shouldHandlerBeCancelledBy(otherHandler, handler)) {
         otherHandler.cancel()
         otherHandler.isAwaiting = false
@@ -218,32 +188,31 @@ 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
-    val handlersCount = gestureHandlersCount
+    preparedHandlers.clear()
+    preparedHandlers.addAll(gestureHandlers)
 
-    gestureHandlers.copyInto(preparedHandlers, 0, 0, handlersCount)
     // 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, 0, handlersCount)
-    for (i in 0 until handlersCount) {
-      deliverEventToGestureHandler(preparedHandlers[i]!!, event)
+    preparedHandlers.sortWith(handlersComparator)
+    for (handler in preparedHandlers) {
+      deliverEventToGestureHandler(handler, event)
     }
   }
 
   private fun cancelAll() {
-    for (i in awaitingHandlersCount - 1 downTo 0) {
-      awaitingHandlers[i]!!.cancel()
+    for (handler in awaitingHandlers.reversed()) {
+      handler.cancel()
     }
     // Copy handlers to "prepared handlers" array, because the list of active handlers can change
     // as a result of state updates
-    val handlersCount = gestureHandlersCount
-    for (i in 0 until handlersCount) {
-      preparedHandlers[i] = gestureHandlers[i]
-    }
-    for (i in handlersCount - 1 downTo 0) {
-      preparedHandlers[i]!!.cancel()
+    preparedHandlers.clear()
+    preparedHandlers.addAll(gestureHandlers)
+
+    for (handler in gestureHandlers.reversed()) {
+      handler.cancel()
     }
   }
 
@@ -325,7 +294,7 @@ class GestureHandlerOrchestrator(
     return parent === wrapperView
   }
 
-  fun isAnyHandlerActive() = gestureHandlers.any { it?.state == GestureHandler.STATE_ACTIVE }
+  fun isAnyHandlerActive() = gestureHandlers.any { it.state == GestureHandler.STATE_ACTIVE }
 
   /**
    * Transforms an event in the coordinates of wrapperView into the coordinate space of the received view.
@@ -399,13 +368,11 @@ class GestureHandlerOrchestrator(
   }
 
   private fun addAwaitingHandler(handler: GestureHandler<*>) {
-    for (i in 0 until awaitingHandlersCount) {
-      if (awaitingHandlers[i] === handler) {
-        return
-      }
+    if (awaitingHandlers.contains(handler)) {
+      return
     }
-    check(awaitingHandlersCount < awaitingHandlers.size) { "Too many recognizers" }
-    awaitingHandlers[awaitingHandlersCount++] = handler
+
+    awaitingHandlers.add(handler)
     with(handler) {
       isAwaiting = true
       activationIndex = this@GestureHandlerOrchestrator.activationIndex++
@@ -413,13 +380,11 @@ class GestureHandlerOrchestrator(
   }
 
   private fun recordHandlerIfNotPresent(handler: GestureHandler<*>, view: View) {
-    for (i in 0 until gestureHandlersCount) {
-      if (gestureHandlers[i] === handler) {
-        return
-      }
+    if (gestureHandlers.contains(handler)) {
+      return
     }
-    check(gestureHandlersCount < gestureHandlers.size) { "Too many recognizers" }
-    gestureHandlers[gestureHandlersCount++] = handler
+
+    gestureHandlers.add(handler)
     handler.isActive = false
     handler.isAwaiting = false
     handler.activationIndex = Int.MAX_VALUE
@@ -608,7 +573,6 @@ class GestureHandlerOrchestrator(
   companion object {
     // The limit doesn't necessarily need to exists, it was just simpler to implement it that way
     // it is also more allocation-wise efficient to have a fixed limit
-    private const val SIMULTANEOUS_GESTURE_HANDLER_LIMIT = 20
 
     // Be default fully transparent views can receive touch
     private const val DEFAULT_MIN_ALPHA_FOR_TRAVERSAL = 0f

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

@@ -13,4 +13,4 @@ val ReactContext.UIManager: UIManagerModule
   get() = this.getNativeModule(UIManagerModule::class.java)!!
 
 fun Context.isScreenReaderOn() =
-  (getSystemService(Context.ACCESSIBILITY_SERVICE) as AccessibilityManager).isEnabled
+  (getSystemService(Context.ACCESSIBILITY_SERVICE) as AccessibilityManager).isTouchExplorationEnabled

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

@@ -12,9 +12,10 @@ import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.events.Event
 import com.facebook.react.uimanager.events.RCTEventEmitter
 import com.swmansion.gesturehandler.core.GestureHandler
+import com.swmansion.gesturehandler.react.eventbuilders.GestureHandlerEventDataBuilder
 
 class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>() {
-  private var extraData: WritableMap? = null
+  private var dataBuilder: GestureHandlerEventDataBuilder<*>? = null
   private var coalescingKey: Short = 0
 
   // On the new architecture, native animated expects event names prefixed with `top` instead of `on`,
@@ -26,17 +27,17 @@ class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>
 
   private fun <T : GestureHandler<T>> init(
     handler: T,
-    dataExtractor: RNGestureHandlerEventDataExtractor<T>?,
+    dataBuilder: GestureHandlerEventDataBuilder<T>,
     useNativeAnimatedName: Boolean
   ) {
     super.init(handler.view!!.id)
-    extraData = createEventData(handler, dataExtractor)
-    coalescingKey = handler.eventCoalescingKey
+    this.dataBuilder = dataBuilder
     this.useTopPrefixedName = useNativeAnimatedName
+    coalescingKey = handler.eventCoalescingKey
   }
 
   override fun onDispose() {
-    extraData = null
+    dataBuilder = null
     EVENTS_POOL.release(this)
   }
 
@@ -47,7 +48,7 @@ class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>
   override fun getCoalescingKey() = coalescingKey
 
   override fun dispatch(rctEventEmitter: RCTEventEmitter) {
-    rctEventEmitter.receiveEvent(viewTag, EVENT_NAME, extraData)
+    rctEventEmitter.receiveEvent(viewTag, EVENT_NAME, createEventData(dataBuilder!!))
   }
 
   companion object {
@@ -58,20 +59,17 @@ class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>
 
     fun <T : GestureHandler<T>> obtain(
       handler: T,
-      dataExtractor: RNGestureHandlerEventDataExtractor<T>?,
+      dataBuilder: GestureHandlerEventDataBuilder<T>,
       useTopPrefixedName: Boolean = false
     ): RNGestureHandlerEvent =
       (EVENTS_POOL.acquire() ?: RNGestureHandlerEvent()).apply {
-        init(handler, dataExtractor, useTopPrefixedName)
+        init(handler, dataBuilder, useTopPrefixedName)
       }
 
-    fun <T : GestureHandler<T>> createEventData(
-      handler: T,
-      dataExtractor: RNGestureHandlerEventDataExtractor<T>?
+    fun createEventData(
+      dataBuilder: GestureHandlerEventDataBuilder<*>
     ): WritableMap = Arguments.createMap().apply {
-      dataExtractor?.extractEventData(handler, this)
-      putInt("handlerTag", handler.tag)
-      putInt("state", handler.state)
+      dataBuilder.buildEventData(this)
     }
   }
 }

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

@@ -9,6 +9,8 @@ import com.swmansion.gesturehandler.core.NativeViewGestureHandler
 class RNGestureHandlerInteractionManager : GestureHandlerInteractionController {
   private val waitForRelations = SparseArray<IntArray>()
   private val simultaneousRelations = SparseArray<IntArray>()
+  private val blockingRelations = SparseArray<IntArray>()
+
   fun dropRelationsForHandlerWithTag(handlerTag: Int) {
     waitForRelations.remove(handlerTag)
     simultaneousRelations.remove(handlerTag)
@@ -33,6 +35,10 @@ class RNGestureHandlerInteractionManager : GestureHandlerInteractionController {
       val tags = convertHandlerTagsArray(config, KEY_SIMULTANEOUS_HANDLERS)
       simultaneousRelations.put(handler.tag, tags)
     }
+    if (config.hasKey(KEY_BLOCKS_HANDLERS)) {
+      val tags = convertHandlerTagsArray(config, KEY_BLOCKS_HANDLERS)
+      blockingRelations.put(handler.tag, tags)
+    }
   }
 
   override fun shouldWaitForHandlerFailure(handler: GestureHandler<*>, otherHandler: GestureHandler<*>) =
@@ -41,7 +47,7 @@ class RNGestureHandlerInteractionManager : GestureHandlerInteractionController {
   override fun shouldRequireHandlerToWaitForFailure(
     handler: GestureHandler<*>,
     otherHandler: GestureHandler<*>,
-  ) = false
+  ) = blockingRelations[handler.tag]?.any { tag -> tag == otherHandler.tag } ?: false
 
   override fun shouldHandlerBeCancelledBy(handler: GestureHandler<*>, otherHandler: GestureHandler<*>): Boolean {
     if (otherHandler is NativeViewGestureHandler) {
@@ -63,5 +69,6 @@ class RNGestureHandlerInteractionManager : GestureHandlerInteractionController {
   companion object {
     private const val KEY_WAIT_FOR = "waitFor"
     private const val KEY_SIMULTANEOUS_HANDLERS = "simultaneousHandlers"
+    private const val KEY_BLOCKS_HANDLERS = "blocksHandlers"
   }
 }

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

@@ -30,6 +30,16 @@ import com.swmansion.gesturehandler.core.PinchGestureHandler
 import com.swmansion.gesturehandler.core.RotationGestureHandler
 import com.swmansion.gesturehandler.core.TapGestureHandler
 import com.swmansion.gesturehandler.dispatchEvent
+import com.swmansion.gesturehandler.react.eventbuilders.FlingGestureHandlerEventDataBuilder
+import com.swmansion.gesturehandler.react.eventbuilders.GestureHandlerEventDataBuilder
+import com.swmansion.gesturehandler.react.eventbuilders.HoverGestureHandlerEventDataBuilder
+import com.swmansion.gesturehandler.react.eventbuilders.LongPressGestureHandlerEventDataBuilder
+import com.swmansion.gesturehandler.react.eventbuilders.ManualGestureHandlerEventDataBuilder
+import com.swmansion.gesturehandler.react.eventbuilders.NativeGestureHandlerEventDataBuilder
+import com.swmansion.gesturehandler.react.eventbuilders.PanGestureHandlerEventDataBuilder
+import com.swmansion.gesturehandler.react.eventbuilders.PinchGestureHandlerEventDataBuilder
+import com.swmansion.gesturehandler.react.eventbuilders.RotationGestureHandlerEventDataBuilder
+import com.swmansion.gesturehandler.react.eventbuilders.TapGestureHandlerEventDataBuilder
 
 // NativeModule.onCatalystInstanceDestroy() was deprecated in favor of NativeModule.invalidate()
 // ref: https://github.com/facebook/react-native/commit/18c8417290823e67e211bde241ae9dde27b72f17
@@ -40,7 +50,7 @@ import com.swmansion.gesturehandler.dispatchEvent
 @ReactModule(name = RNGestureHandlerModule.MODULE_NAME)
 class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   ReactContextBaseJavaModule(reactContext), GestureHandlerStateManager {
-  private abstract class HandlerFactory<T : GestureHandler<T>> : RNGestureHandlerEventDataExtractor<T> {
+  private abstract class HandlerFactory<T : GestureHandler<T>> {
     abstract val type: Class<T>
     abstract val name: String
     abstract fun create(context: Context?): T
@@ -63,9 +73,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       }
     }
 
-    override fun extractEventData(handler: T, eventData: WritableMap) {
-      eventData.putDouble("numberOfPointers", handler.numberOfPointers.toDouble())
-    }
+    abstract fun createEventBuilder(handler: T): GestureHandlerEventDataBuilder<T>
   }
 
   private class NativeViewGestureHandlerFactory : HandlerFactory<NativeViewGestureHandler>() {
@@ -88,10 +96,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       }
     }
 
-    override fun extractEventData(handler: NativeViewGestureHandler, eventData: WritableMap) {
-      super.extractEventData(handler, eventData)
-      eventData.putBoolean("pointerInside", handler.isWithinBounds)
-    }
+    override fun createEventBuilder(handler: NativeViewGestureHandler) = NativeGestureHandlerEventDataBuilder(handler)
   }
 
   private class TapGestureHandlerFactory : HandlerFactory<TapGestureHandler>() {
@@ -127,15 +132,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       }
     }
 
-    override fun extractEventData(handler: TapGestureHandler, eventData: WritableMap) {
-      super.extractEventData(handler, eventData)
-      with(eventData) {
-        putDouble("x", PixelUtil.toDIPFromPixel(handler.lastRelativePositionX).toDouble())
-        putDouble("y", PixelUtil.toDIPFromPixel(handler.lastRelativePositionY).toDouble())
-        putDouble("absoluteX", PixelUtil.toDIPFromPixel(handler.lastPositionInWindowX).toDouble())
-        putDouble("absoluteY", PixelUtil.toDIPFromPixel(handler.lastPositionInWindowY).toDouble())
-      }
-    }
+    override fun createEventBuilder(handler: TapGestureHandler) = TapGestureHandlerEventDataBuilder(handler)
   }
 
   private class LongPressGestureHandlerFactory : HandlerFactory<LongPressGestureHandler>() {
@@ -156,16 +153,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       }
     }
 
-    override fun extractEventData(handler: LongPressGestureHandler, eventData: WritableMap) {
-      super.extractEventData(handler, eventData)
-      with(eventData) {
-        putDouble("x", PixelUtil.toDIPFromPixel(handler.lastRelativePositionX).toDouble())
-        putDouble("y", PixelUtil.toDIPFromPixel(handler.lastRelativePositionY).toDouble())
-        putDouble("absoluteX", PixelUtil.toDIPFromPixel(handler.lastPositionInWindowX).toDouble())
-        putDouble("absoluteY", PixelUtil.toDIPFromPixel(handler.lastPositionInWindowY).toDouble())
-        putInt("duration", handler.duration)
-      }
-    }
+    override fun createEventBuilder(handler: LongPressGestureHandler) = LongPressGestureHandlerEventDataBuilder(handler)
   }
 
   private class PanGestureHandlerFactory : HandlerFactory<PanGestureHandler>() {
@@ -247,19 +235,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       }
     }
 
-    override fun extractEventData(handler: PanGestureHandler, eventData: WritableMap) {
-      super.extractEventData(handler, eventData)
-      with(eventData) {
-        putDouble("x", PixelUtil.toDIPFromPixel(handler.lastRelativePositionX).toDouble())
-        putDouble("y", PixelUtil.toDIPFromPixel(handler.lastRelativePositionY).toDouble())
-        putDouble("absoluteX", PixelUtil.toDIPFromPixel(handler.lastPositionInWindowX).toDouble())
-        putDouble("absoluteY", PixelUtil.toDIPFromPixel(handler.lastPositionInWindowY).toDouble())
-        putDouble("translationX", PixelUtil.toDIPFromPixel(handler.translationX).toDouble())
-        putDouble("translationY", PixelUtil.toDIPFromPixel(handler.translationY).toDouble())
-        putDouble("velocityX", PixelUtil.toDIPFromPixel(handler.velocityX).toDouble())
-        putDouble("velocityY", PixelUtil.toDIPFromPixel(handler.velocityY).toDouble())
-      }
-    }
+    override fun createEventBuilder(handler: PanGestureHandler) = PanGestureHandlerEventDataBuilder(handler)
   }
 
   private class PinchGestureHandlerFactory : HandlerFactory<PinchGestureHandler>() {
@@ -270,15 +246,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       return PinchGestureHandler()
     }
 
-    override fun extractEventData(handler: PinchGestureHandler, eventData: WritableMap) {
-      super.extractEventData(handler, eventData)
-      with(eventData) {
-        putDouble("scale", handler.scale)
-        putDouble("focalX", PixelUtil.toDIPFromPixel(handler.focalPointX).toDouble())
-        putDouble("focalY", PixelUtil.toDIPFromPixel(handler.focalPointY).toDouble())
-        putDouble("velocity", handler.velocity)
-      }
-    }
+    override fun createEventBuilder(handler: PinchGestureHandler) = PinchGestureHandlerEventDataBuilder(handler)
   }
 
   private class FlingGestureHandlerFactory : HandlerFactory<FlingGestureHandler>() {
@@ -299,15 +267,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       }
     }
 
-    override fun extractEventData(handler: FlingGestureHandler, eventData: WritableMap) {
-      super.extractEventData(handler, eventData)
-      with(eventData) {
-        putDouble("x", PixelUtil.toDIPFromPixel(handler.lastRelativePositionX).toDouble())
-        putDouble("y", PixelUtil.toDIPFromPixel(handler.lastRelativePositionY).toDouble())
-        putDouble("absoluteX", PixelUtil.toDIPFromPixel(handler.lastPositionInWindowX).toDouble())
-        putDouble("absoluteY", PixelUtil.toDIPFromPixel(handler.lastPositionInWindowY).toDouble())
-      }
-    }
+    override fun createEventBuilder(handler: FlingGestureHandler) = FlingGestureHandlerEventDataBuilder(handler)
   }
 
   private class RotationGestureHandlerFactory : HandlerFactory<RotationGestureHandler>() {
@@ -318,15 +278,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       return RotationGestureHandler()
     }
 
-    override fun extractEventData(handler: RotationGestureHandler, eventData: WritableMap) {
-      super.extractEventData(handler, eventData)
-      with(eventData) {
-        putDouble("rotation", handler.rotation)
-        putDouble("anchorX", PixelUtil.toDIPFromPixel(handler.anchorX).toDouble())
-        putDouble("anchorY", PixelUtil.toDIPFromPixel(handler.anchorY).toDouble())
-        putDouble("velocity", handler.velocity)
-      }
-    }
+    override fun createEventBuilder(handler: RotationGestureHandler) = RotationGestureHandlerEventDataBuilder(handler)
   }
 
   private class ManualGestureHandlerFactory : HandlerFactory<ManualGestureHandler>() {
@@ -336,6 +288,8 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
     override fun create(context: Context?): ManualGestureHandler {
       return ManualGestureHandler()
     }
+
+    override fun createEventBuilder(handler: ManualGestureHandler) = ManualGestureHandlerEventDataBuilder(handler)
   }
 
   private class HoverGestureHandlerFactory : HandlerFactory<HoverGestureHandler>() {
@@ -346,15 +300,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       return HoverGestureHandler()
     }
 
-    override fun extractEventData(handler: HoverGestureHandler, eventData: WritableMap) {
-      super.extractEventData(handler, eventData)
-      with(eventData) {
-        putDouble("x", PixelUtil.toDIPFromPixel(handler.lastRelativePositionX).toDouble())
-        putDouble("y", PixelUtil.toDIPFromPixel(handler.lastRelativePositionY).toDouble())
-        putDouble("absoluteX", PixelUtil.toDIPFromPixel(handler.lastPositionInWindowX).toDouble())
-        putDouble("absoluteY", PixelUtil.toDIPFromPixel(handler.lastPositionInWindowY).toDouble())
-      }
-    }
+    override fun createEventBuilder(handler: HoverGestureHandler) = HoverGestureHandlerEventDataBuilder(handler)
   }
 
   private val eventListener = object : OnTouchEventListener {
@@ -466,7 +412,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   fun install(): Boolean {
     return try {
       SoLoader.loadLibrary("gesturehandler")
-      val jsContext = reactApplicationContext.javaScriptContextHolder
+      val jsContext = reactApplicationContext.javaScriptContextHolder!!
       decorateRuntime(jsContext.get())
       true
     } catch (exception: Exception) {
@@ -551,32 +497,32 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       return
     }
     if (handler.state == GestureHandler.STATE_ACTIVE) {
-      val handlerFactory = findFactoryForHandler(handler)
+      val handlerFactory = findFactoryForHandler(handler) ?: return
 
       if (handler.actionType == GestureHandler.ACTION_TYPE_REANIMATED_WORKLET) {
         // Reanimated worklet
-        val event = RNGestureHandlerEvent.obtain(handler, handlerFactory)
+        val event = RNGestureHandlerEvent.obtain(handler, handlerFactory.createEventBuilder(handler))
         sendEventForReanimated(event)
       } else if (handler.actionType == GestureHandler.ACTION_TYPE_NATIVE_ANIMATED_EVENT) {
         // Animated with useNativeDriver: true
         val event = RNGestureHandlerEvent.obtain(
           handler,
-          handlerFactory,
+          handlerFactory.createEventBuilder(handler),
           useTopPrefixedName = BuildConfig.REACT_NATIVE_MINOR_VERSION >= 71
         )
         sendEventForNativeAnimatedEvent(event)
       } else if (handler.actionType == GestureHandler.ACTION_TYPE_JS_FUNCTION_OLD_API) {
         // JS function, Animated.event with useNativeDriver: false using old API
         if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
-          val data = RNGestureHandlerEvent.createEventData(handler, handlerFactory)
+          val data = RNGestureHandlerEvent.createEventData(handlerFactory.createEventBuilder(handler))
           sendEventForDeviceEvent(RNGestureHandlerEvent.EVENT_NAME, data)
         } else {
-          val event = RNGestureHandlerEvent.obtain(handler, handlerFactory)
+          val event = RNGestureHandlerEvent.obtain(handler, handlerFactory.createEventBuilder(handler))
           sendEventForDirectEvent(event)
         }
       } else if (handler.actionType == GestureHandler.ACTION_TYPE_JS_FUNCTION_NEW_API) {
         // JS function, Animated.event with useNativeDriver: false using new API
-        val data = RNGestureHandlerEvent.createEventData(handler, handlerFactory)
+        val data = RNGestureHandlerEvent.createEventData(handlerFactory.createEventBuilder(handler))
         sendEventForDeviceEvent(RNGestureHandlerEvent.EVENT_NAME, data)
       }
     }
@@ -589,26 +535,26 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       // root containers use negative tags, we don't need to dispatch events for them to the JS
       return
     }
-    val handlerFactory = findFactoryForHandler(handler)
+    val handlerFactory = findFactoryForHandler(handler) ?: return
 
     if (handler.actionType == GestureHandler.ACTION_TYPE_REANIMATED_WORKLET) {
       // Reanimated worklet
-      val event = RNGestureHandlerStateChangeEvent.obtain(handler, newState, oldState, handlerFactory)
+      val event = RNGestureHandlerStateChangeEvent.obtain(handler, newState, oldState, handlerFactory.createEventBuilder(handler))
       sendEventForReanimated(event)
     } else if (handler.actionType == GestureHandler.ACTION_TYPE_NATIVE_ANIMATED_EVENT ||
       handler.actionType == GestureHandler.ACTION_TYPE_JS_FUNCTION_OLD_API
     ) {
       // JS function or Animated.event with useNativeDriver: false with old API
       if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
-        val data = RNGestureHandlerStateChangeEvent.createEventData(handler, handlerFactory, newState, oldState)
+        val data = RNGestureHandlerStateChangeEvent.createEventData(handlerFactory.createEventBuilder(handler), newState, oldState)
         sendEventForDeviceEvent(RNGestureHandlerStateChangeEvent.EVENT_NAME, data)
       } else {
-        val event = RNGestureHandlerStateChangeEvent.obtain(handler, newState, oldState, handlerFactory)
+        val event = RNGestureHandlerStateChangeEvent.obtain(handler, newState, oldState, handlerFactory.createEventBuilder(handler))
         sendEventForDirectEvent(event)
       }
     } else if (handler.actionType == GestureHandler.ACTION_TYPE_JS_FUNCTION_NEW_API) {
       // JS function or Animated.event with useNativeDriver: false with new API
-      val data = RNGestureHandlerStateChangeEvent.createEventData(handler, handlerFactory, newState, oldState)
+      val data = RNGestureHandlerStateChangeEvent.createEventData(handlerFactory.createEventBuilder(handler), newState, oldState)
       sendEventForDeviceEvent(RNGestureHandlerStateChangeEvent.EVENT_NAME, data)
     }
   }

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

@@ -40,7 +40,7 @@ class RNGestureHandlerRootView(context: Context?) : ReactViewGroup(context) {
   override fun dispatchGenericMotionEvent(event: MotionEvent) =
     if (_enabled && rootHelper!!.dispatchTouchEvent(event)) {
       true
-    } else super.dispatchTouchEvent(event)
+    } else super.dispatchGenericMotionEvent(event)
 
   override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
     if (_enabled) {