react-native-gesture-handler 2.25.0 → 2.27.0

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

@@ -16,7 +16,7 @@ data class StylusData(
   val tiltY: Double = 0.0,
   val altitudeAngle: Double = 0.0,
   val azimuthAngle: Double = 0.0,
-  val pressure: Double = -1.0
+  val pressure: Double = -1.0,
 ) {
   fun toReadableMap(): ReadableMap {
     val stylusDataObject = Arguments.createMap().apply {

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

@@ -1,16 +1,20 @@
 package com.swmansion.gesturehandler.core
 
+import android.content.Context
 import android.os.Handler
 import android.os.Looper
 import android.view.MotionEvent
+import com.facebook.react.bridge.ReadableMap
+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.TapGestureHandlerEventDataBuilder
 import kotlin.math.abs
 
-class TapGestureHandler : GestureHandler<TapGestureHandler>() {
+class TapGestureHandler : GestureHandler() {
   private var maxDeltaX = MAX_VALUE_IGNORE
   private var maxDeltaY = MAX_VALUE_IGNORE
-  private var maxDistSq = MAX_VALUE_IGNORE
+  private var maxDist = MAX_VALUE_IGNORE
   private var maxDurationMs = DEFAULT_MAX_DURATION_MS
   private var maxDelayMs = DEFAULT_MAX_DELAY_MS
   private var numberOfTaps = DEFAULT_NUMBER_OF_TAPS
@@ -27,46 +31,19 @@ class TapGestureHandler : GestureHandler<TapGestureHandler>() {
   private val failDelayed = Runnable { fail() }
 
   init {
-    setShouldCancelWhenOutside(true)
+    shouldCancelWhenOutside = true
   }
 
   override fun resetConfig() {
     super.resetConfig()
     maxDeltaX = MAX_VALUE_IGNORE
     maxDeltaY = MAX_VALUE_IGNORE
-    maxDistSq = MAX_VALUE_IGNORE
+    maxDist = MAX_VALUE_IGNORE
     maxDurationMs = DEFAULT_MAX_DURATION_MS
     maxDelayMs = DEFAULT_MAX_DELAY_MS
     numberOfTaps = DEFAULT_NUMBER_OF_TAPS
     minNumberOfPointers = DEFAULT_MIN_NUMBER_OF_POINTERS
-  }
-
-  fun setNumberOfTaps(numberOfTaps: Int) = apply {
-    this.numberOfTaps = numberOfTaps
-  }
-
-  fun setMaxDelayMs(maxDelayMs: Long) = apply {
-    this.maxDelayMs = maxDelayMs
-  }
-
-  fun setMaxDurationMs(maxDurationMs: Long) = apply {
-    this.maxDurationMs = maxDurationMs
-  }
-
-  fun setMaxDx(deltaX: Float) = apply {
-    maxDeltaX = deltaX
-  }
-
-  fun setMaxDy(deltaY: Float) = apply {
-    maxDeltaY = deltaY
-  }
-
-  fun setMaxDist(maxDist: Float) = apply {
-    maxDistSq = maxDist * maxDist
-  }
-
-  fun setMinNumberOfPointers(minNumberOfPointers: Int) = apply {
-    this.minNumberOfPointers = minNumberOfPointers
+    shouldCancelWhenOutside = DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE
   }
 
   private fun startTap() {
@@ -101,7 +78,7 @@ class TapGestureHandler : GestureHandler<TapGestureHandler>() {
       return true
     }
     val dist = dy * dy + dx * dx
-    return maxDistSq != MAX_VALUE_IGNORE && dist > maxDistSq
+    return maxDist != MAX_VALUE_IGNORE && dist > maxDist * maxDist
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
@@ -162,11 +139,56 @@ class TapGestureHandler : GestureHandler<TapGestureHandler>() {
     handler?.removeCallbacksAndMessages(null)
   }
 
+  class Factory : GestureHandler.Factory<TapGestureHandler>() {
+    override val type = TapGestureHandler::class.java
+    override val name = "TapGestureHandler"
+
+    override fun create(context: Context?): TapGestureHandler = TapGestureHandler()
+
+    override fun setConfig(handler: TapGestureHandler, config: ReadableMap) {
+      super.setConfig(handler, config)
+      if (config.hasKey(KEY_NUMBER_OF_TAPS)) {
+        handler.numberOfTaps = config.getInt(KEY_NUMBER_OF_TAPS)
+      }
+      if (config.hasKey(KEY_MAX_DURATION_MS)) {
+        handler.maxDurationMs = config.getInt(KEY_MAX_DURATION_MS).toLong()
+      }
+      if (config.hasKey(KEY_MAX_DELAY_MS)) {
+        handler.maxDelayMs = config.getInt(KEY_MAX_DELAY_MS).toLong()
+      }
+      if (config.hasKey(KEY_MAX_DELTA_X)) {
+        handler.maxDeltaX = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MAX_DELTA_X))
+      }
+      if (config.hasKey(KEY_MAX_DELTA_Y)) {
+        handler.maxDeltaY = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MAX_DELTA_Y))
+      }
+      if (config.hasKey(KEY_MAX_DIST)) {
+        handler.maxDist = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MAX_DIST))
+      }
+      if (config.hasKey(KEY_MIN_POINTERS)) {
+        handler.minNumberOfPointers = config.getInt(KEY_MIN_POINTERS)
+      }
+    }
+
+    override fun createEventBuilder(handler: TapGestureHandler) = TapGestureHandlerEventDataBuilder(handler)
+
+    companion object {
+      private const val KEY_NUMBER_OF_TAPS = "numberOfTaps"
+      private const val KEY_MAX_DURATION_MS = "maxDurationMs"
+      private const val KEY_MAX_DELAY_MS = "maxDelayMs"
+      private const val KEY_MAX_DELTA_X = "maxDeltaX"
+      private const val KEY_MAX_DELTA_Y = "maxDeltaY"
+      private const val KEY_MAX_DIST = "maxDist"
+      private const val KEY_MIN_POINTERS = "minPointers"
+    }
+  }
+
   companion object {
     private const val MAX_VALUE_IGNORE = Float.MIN_VALUE
     private const val DEFAULT_MAX_DURATION_MS: Long = 500
     private const val DEFAULT_MAX_DELAY_MS: Long = 200
     private const val DEFAULT_NUMBER_OF_TAPS = 1
     private const val DEFAULT_MIN_NUMBER_OF_POINTERS = 1
+    private const val DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE = true
   }
 }

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

@@ -19,13 +19,9 @@ class Vector(val x: Double, val y: Double) {
     unitY = if (isMagnitudeSufficient) y / magnitude else 0.0
   }
 
-  private fun computeSimilarity(vector: Vector): Double {
-    return unitX * vector.unitX + unitY * vector.unitY
-  }
+  private fun computeSimilarity(vector: Vector): Double = unitX * vector.unitX + unitY * vector.unitY
 
-  fun isSimilar(vector: Vector, threshold: Double): Boolean {
-    return computeSimilarity(vector) > threshold
-  }
+  fun isSimilar(vector: Vector, threshold: Double): Boolean = computeSimilarity(vector) > threshold
 
   companion object {
     private val VECTOR_LEFT: Vector = Vector(-1.0, 0.0)
@@ -41,18 +37,17 @@ class Vector(val x: Double, val y: Double) {
     private val VECTOR_ZERO: Vector = Vector(0.0, 0.0)
     private const val MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1
 
-    fun fromDirection(direction: Int): Vector =
-      when (direction) {
-        DIRECTION_LEFT -> VECTOR_LEFT
-        DIRECTION_RIGHT -> VECTOR_RIGHT
-        DIRECTION_UP -> VECTOR_UP
-        DIRECTION_DOWN -> VECTOR_DOWN
-        DiagonalDirections.DIRECTION_RIGHT_UP -> VECTOR_RIGHT_UP
-        DiagonalDirections.DIRECTION_RIGHT_DOWN -> VECTOR_RIGHT_DOWN
-        DiagonalDirections.DIRECTION_LEFT_UP -> VECTOR_LEFT_UP
-        DiagonalDirections.DIRECTION_LEFT_DOWN -> VECTOR_LEFT_DOWN
-        else -> VECTOR_ZERO
-      }
+    fun fromDirection(direction: Int): Vector = when (direction) {
+      DIRECTION_LEFT -> VECTOR_LEFT
+      DIRECTION_RIGHT -> VECTOR_RIGHT
+      DIRECTION_UP -> VECTOR_UP
+      DIRECTION_DOWN -> VECTOR_DOWN
+      DiagonalDirections.DIRECTION_RIGHT_UP -> VECTOR_RIGHT_UP
+      DiagonalDirections.DIRECTION_RIGHT_DOWN -> VECTOR_RIGHT_DOWN
+      DiagonalDirections.DIRECTION_LEFT_UP -> VECTOR_LEFT_UP
+      DiagonalDirections.DIRECTION_LEFT_DOWN -> VECTOR_LEFT_DOWN
+      else -> VECTOR_ZERO
+    }
 
     fun fromVelocity(tracker: VelocityTracker): Vector {
       tracker.computeCurrentVelocity(1000)

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

@@ -38,7 +38,9 @@ import com.swmansion.gesturehandler.core.NativeViewGestureHandler
 import com.swmansion.gesturehandler.react.RNGestureHandlerButtonViewManager.ButtonViewGroup
 
 @ReactModule(name = RNGestureHandlerButtonViewManager.REACT_CLASS)
-class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), RNGestureHandlerButtonManagerInterface<ButtonViewGroup> {
+class RNGestureHandlerButtonViewManager :
+  ViewGroupManager<ButtonViewGroup>(),
+  RNGestureHandlerButtonManagerInterface<ButtonViewGroup> {
   private val mDelegate: ViewManagerDelegate<ButtonViewGroup>
 
   init {
@@ -136,9 +138,7 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
     view.updateBackground()
   }
 
-  override fun getDelegate(): ViewManagerDelegate<ButtonViewGroup>? {
-    return mDelegate
-  }
+  override fun getDelegate(): ViewManagerDelegate<ButtonViewGroup>? = mDelegate
 
   class ButtonViewGroup(context: Context?) :
     ViewGroup(context),
@@ -200,7 +200,7 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
 
     var exclusive = true
 
-    private var _backgroundColor = Color.TRANSPARENT
+    private var buttonBackgroundColor = Color.TRANSPARENT
     private var needBackgroundUpdate = false
     private var lastEventTime = -1L
     private var lastAction = -1
@@ -238,16 +238,14 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
         .toFloatArray()
     }
 
-    private fun buildBorderStyle(): PathEffect? {
-      return when (borderStyle) {
-        "dotted" -> DashPathEffect(floatArrayOf(borderWidth, borderWidth, borderWidth, borderWidth), 0f)
-        "dashed" -> DashPathEffect(floatArrayOf(borderWidth * 3, borderWidth * 3, borderWidth * 3, borderWidth * 3), 0f)
-        else -> null
-      }
+    private fun buildBorderStyle(): PathEffect? = when (borderStyle) {
+      "dotted" -> DashPathEffect(floatArrayOf(borderWidth, borderWidth, borderWidth, borderWidth), 0f)
+      "dashed" -> DashPathEffect(floatArrayOf(borderWidth * 3, borderWidth * 3, borderWidth * 3, borderWidth * 3), 0f)
+      else -> null
     }
 
     override fun setBackgroundColor(color: Int) = withBackgroundUpdate {
-      _backgroundColor = color
+      buttonBackgroundColor = color
     }
 
     override fun onInitializeAccessibilityNodeInfo(info: AccessibilityNodeInfo) {
@@ -325,7 +323,13 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
         colorDrawable.setCornerRadii(buildBorderRadii())
       }
 
-      val layerDrawable = LayerDrawable(if (selectable != null) arrayOf(colorDrawable, selectable, borderDrawable) else arrayOf(colorDrawable, borderDrawable))
+      val layerDrawable = LayerDrawable(
+        if (selectable != null) {
+          arrayOf(colorDrawable, selectable, borderDrawable)
+        } else {
+          arrayOf(colorDrawable, borderDrawable)
+        },
+      )
       background = layerDrawable
     }
 
@@ -335,7 +339,7 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       }
       needBackgroundUpdate = false
 
-      if (_backgroundColor == Color.TRANSPARENT) {
+      if (buttonBackgroundColor == Color.TRANSPARENT) {
         // reset background
         background = null
       }
@@ -355,13 +359,13 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
 
       if (useDrawableOnForeground && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
         foreground = selectable
-        if (_backgroundColor != Color.TRANSPARENT) {
-          updateBackgroundColor(_backgroundColor, borderDrawable, null)
+        if (buttonBackgroundColor != Color.TRANSPARENT) {
+          updateBackgroundColor(buttonBackgroundColor, borderDrawable, null)
         }
-      } else if (_backgroundColor == Color.TRANSPARENT && rippleColor == null) {
+      } else if (buttonBackgroundColor == Color.TRANSPARENT && rippleColor == null) {
         background = LayerDrawable(arrayOf(selectable, borderDrawable))
       } else {
-        updateBackgroundColor(_backgroundColor, borderDrawable, selectable)
+        updateBackgroundColor(buttonBackgroundColor, borderDrawable, selectable)
       }
     }
 
@@ -405,7 +409,7 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       val drawable = RippleDrawable(
         colorStateList,
         null,
-        if (useBorderlessDrawable) null else ShapeDrawable(RectShape())
+        if (useBorderlessDrawable) null else ShapeDrawable(RectShape()),
       )
 
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && rippleRadius != null) {
@@ -426,7 +430,10 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
     }
 
     override fun canBegin(event: MotionEvent): Boolean {
-      if (event.action == MotionEvent.ACTION_CANCEL || event.action == MotionEvent.ACTION_UP || event.actionMasked == MotionEvent.ACTION_POINTER_UP) {
+      if (event.action == MotionEvent.ACTION_CANCEL ||
+        event.action == MotionEvent.ACTION_UP ||
+        event.actionMasked == MotionEvent.ACTION_POINTER_UP
+      ) {
         return false
       }
 
@@ -488,7 +495,6 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       // don't preform click when a child button is pressed (mainly to prevent sound effect of
       // a parent button from playing)
       return if (!isChildTouched()) {
-
         if (context.isScreenReaderOn()) {
           findGestureHandlerRootView()?.activateNativeHandlers(this)
         } else if (receivedKeyEvent) {

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

@@ -4,12 +4,17 @@ import android.content.Context
 import android.util.AttributeSet
 import com.facebook.react.ReactRootView
 
-@Deprecated(message = "Use <GestureHandlerRootView /> component instead. Check gesture handler installation instructions in documentation for more information.")
+@Deprecated(
+  message = "Use <GestureHandlerRootView /> component instead." +
+    "Check gesture handler installation instructions in documentation for more information.",
+)
 class RNGestureHandlerEnabledRootView : ReactRootView {
   constructor(context: Context?) : super(context)
   constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs)
 
   init {
-    throw UnsupportedOperationException("Your application is configured to use RNGestureHandlerEnabledRootView which is no longer supported. You can see how to migrate to <GestureHandlerRootView /> here: https://docs.swmansion.com/react-native-gesture-handler/docs/guides/migrating-off-rnghenabledroot")
+    throw UnsupportedOperationException(
+      "Your application is configured to use RNGestureHandlerEnabledRootView which is no longer supported. You can see how to migrate to <GestureHandlerRootView /> here: https://docs.swmansion.com/react-native-gesture-handler/docs/guides/migrating-off-rnghenabledroot",
+    )
   }
 }

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

@@ -25,10 +25,10 @@ class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>
   // how GH sends events (which needs to be done, but maybe wait until the RN's apis stop changing)
   private var useTopPrefixedName: Boolean = false
 
-  private fun <T : GestureHandler<T>> init(
+  private fun <T : GestureHandler> init(
     handler: T,
     dataBuilder: GestureHandlerEventDataBuilder<T>,
-    useNativeAnimatedName: Boolean
+    useNativeAnimatedName: Boolean,
   ) {
     val view = handler.view!!
     super.init(UIManagerHelper.getSurfaceId(view), view.id)
@@ -42,7 +42,11 @@ class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>
     EVENTS_POOL.release(this)
   }
 
-  override fun getEventName() = if (useTopPrefixedName) NATIVE_ANIMATED_EVENT_NAME else EVENT_NAME
+  override fun getEventName() = if (useTopPrefixedName) {
+    NATIVE_ANIMATED_EVENT_NAME
+  } else {
+    EVENT_NAME
+  }
 
   override fun canCoalesce() = true
 
@@ -56,18 +60,15 @@ class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>
     private const val TOUCH_EVENTS_POOL_SIZE = 7 // magic
     private val EVENTS_POOL = Pools.SynchronizedPool<RNGestureHandlerEvent>(TOUCH_EVENTS_POOL_SIZE)
 
-    fun <T : GestureHandler<T>> obtain(
+    fun <T : GestureHandler> obtain(
       handler: T,
       dataBuilder: GestureHandlerEventDataBuilder<T>,
-      useTopPrefixedName: Boolean = false
-    ): RNGestureHandlerEvent =
-      (EVENTS_POOL.acquire() ?: RNGestureHandlerEvent()).apply {
-        init(handler, dataBuilder, useTopPrefixedName)
-      }
+      useTopPrefixedName: Boolean = false,
+    ): RNGestureHandlerEvent = (EVENTS_POOL.acquire() ?: RNGestureHandlerEvent()).apply {
+      init(handler, dataBuilder, useTopPrefixedName)
+    }
 
-    fun createEventData(
-      dataBuilder: GestureHandlerEventDataBuilder<*>
-    ): WritableMap = Arguments.createMap().apply {
+    fun createEventData(dataBuilder: GestureHandlerEventDataBuilder<*>): WritableMap = Arguments.createMap().apply {
       dataBuilder.buildEventData(this)
     }
   }

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

@@ -0,0 +1,189 @@
+package com.swmansion.gesturehandler.react
+
+import android.view.MotionEvent
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.swmansion.gesturehandler.BuildConfig
+import com.swmansion.gesturehandler.ReanimatedEventDispatcher
+import com.swmansion.gesturehandler.core.GestureHandler
+import com.swmansion.gesturehandler.core.OnTouchEventListener
+import com.swmansion.gesturehandler.dispatchEvent
+
+class RNGestureHandlerEventDispatcher(private val reactApplicationContext: ReactApplicationContext) :
+  OnTouchEventListener {
+  private val reanimatedEventDispatcher = ReanimatedEventDispatcher()
+
+  override fun <T : GestureHandler> onHandlerUpdate(handler: T, event: MotionEvent) {
+    this.dispatchHandlerUpdateEvent(handler)
+  }
+
+  override fun <T : GestureHandler> onStateChange(handler: T, newState: Int, oldState: Int) {
+    this.dispatchStateChangeEvent(handler, newState, oldState)
+  }
+
+  override fun <T : GestureHandler> onTouchEvent(handler: T) {
+    this.dispatchTouchEvent(handler)
+  }
+
+  private fun <T : GestureHandler> dispatchHandlerUpdateEvent(handler: T) {
+    // triggers onUpdate and onChange callbacks on the JS side
+
+    // root containers use negative tags, we don't need to dispatch events for them to the JS
+    if (handler.tag < 0 || handler.state != GestureHandler.STATE_ACTIVE) {
+      return
+    }
+
+    val handlerFactory = RNGestureHandlerFactoryUtil.findFactoryForHandler<GestureHandler>(handler) ?: return
+    when (handler.actionType) {
+      GestureHandler.ACTION_TYPE_REANIMATED_WORKLET -> {
+        // Reanimated worklet
+        val event = RNGestureHandlerEvent.obtain(
+          handler,
+          handlerFactory.createEventBuilder(handler),
+        )
+        sendEventForReanimated(event)
+      }
+      GestureHandler.ACTION_TYPE_NATIVE_ANIMATED_EVENT -> {
+        // Animated with useNativeDriver: true
+        val event = RNGestureHandlerEvent.obtain(
+          handler,
+          handlerFactory.createEventBuilder(handler),
+          true,
+        )
+        sendEventForNativeAnimatedEvent(event)
+      }
+      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(
+            handlerFactory.createEventBuilder(handler),
+          )
+          sendEventForDeviceEvent(RNGestureHandlerEvent.EVENT_NAME, data)
+        } else {
+          val event = RNGestureHandlerEvent.obtain(
+            handler,
+            handlerFactory.createEventBuilder(handler),
+          )
+          sendEventForDirectEvent(event)
+        }
+      }
+      GestureHandler.ACTION_TYPE_JS_FUNCTION_NEW_API -> {
+        // JS function, Animated.event with useNativeDriver: false using new API
+        val data =
+          RNGestureHandlerEvent.createEventData(handlerFactory.createEventBuilder(handler))
+        sendEventForDeviceEvent(RNGestureHandlerEvent.EVENT_NAME, data)
+      }
+    }
+  }
+
+  private fun <T : GestureHandler> dispatchStateChangeEvent(handler: T, newState: Int, oldState: Int) {
+    // triggers onBegin, onStart, onEnd, onFinalize callbacks on the JS side
+
+    if (handler.tag < 0) {
+      // root containers use negative tags, we don't need to dispatch events for them to the JS
+      return
+    }
+    val handlerFactory = RNGestureHandlerFactoryUtil.findFactoryForHandler<GestureHandler>(handler) ?: return
+
+    when (handler.actionType) {
+      GestureHandler.ACTION_TYPE_REANIMATED_WORKLET -> {
+        // Reanimated worklet
+        val event = RNGestureHandlerStateChangeEvent.obtain(
+          handler,
+          newState,
+          oldState,
+          handlerFactory.createEventBuilder(handler),
+        )
+        sendEventForReanimated(event)
+      }
+      GestureHandler.ACTION_TYPE_NATIVE_ANIMATED_EVENT, 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(
+            handlerFactory.createEventBuilder(handler),
+            newState,
+            oldState,
+          )
+          sendEventForDeviceEvent(RNGestureHandlerStateChangeEvent.EVENT_NAME, data)
+        } else {
+          val event = RNGestureHandlerStateChangeEvent.obtain(
+            handler,
+            newState,
+            oldState,
+            handlerFactory.createEventBuilder(handler),
+          )
+          sendEventForDirectEvent(event)
+        }
+      }
+      GestureHandler.ACTION_TYPE_JS_FUNCTION_NEW_API -> {
+        // JS function or Animated.event with useNativeDriver: false with new API
+        val data = RNGestureHandlerStateChangeEvent.createEventData(
+          handlerFactory.createEventBuilder(handler),
+          newState,
+          oldState,
+        )
+        sendEventForDeviceEvent(RNGestureHandlerStateChangeEvent.EVENT_NAME, data)
+      }
+    }
+  }
+
+  private fun <T : GestureHandler> dispatchTouchEvent(handler: T) {
+    // triggers onTouchesDown, onTouchesMove, onTouchesUp, onTouchesCancelled callbacks on the JS side
+
+    if (handler.tag < 0) {
+      // root containers use negative tags, we don't need to dispatch events for them to the JS
+      return
+    }
+
+    if (handler.state != GestureHandler.STATE_BEGAN &&
+      handler.state != GestureHandler.STATE_ACTIVE &&
+      handler.state != GestureHandler.STATE_UNDETERMINED &&
+      handler.view == null
+    ) {
+      return
+    }
+
+    when (handler.actionType) {
+      GestureHandler.ACTION_TYPE_REANIMATED_WORKLET -> {
+        // Reanimated worklet
+        val event = RNGestureHandlerTouchEvent.obtain(handler)
+        sendEventForReanimated(event)
+      }
+      GestureHandler.ACTION_TYPE_JS_FUNCTION_NEW_API -> {
+        // JS function, Animated.event with useNativeDriver: false with new API
+        val data = RNGestureHandlerTouchEvent.createEventData(handler)
+        sendEventForDeviceEvent(RNGestureHandlerEvent.EVENT_NAME, data)
+      }
+    }
+  }
+
+  private fun <T : Event<T>> sendEventForReanimated(event: T) {
+    // Delivers the event to Reanimated.
+    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+      // Send event directly to Reanimated
+      reanimatedEventDispatcher.sendEvent(event, reactApplicationContext)
+    } else {
+      // In the old architecture, Reanimated subscribes for specific direct events.
+      sendEventForDirectEvent(event)
+    }
+  }
+
+  private fun sendEventForNativeAnimatedEvent(event: RNGestureHandlerEvent) {
+    // Delivers the event to NativeAnimatedModule.
+    // TODO: send event directly to NativeAnimated[Turbo]Module
+    // ReactContext.dispatchEvent is an extension function, depending on the architecture it will
+    // dispatch event using UIManagerModule or FabricUIManager.
+    reactApplicationContext.dispatchEvent(event)
+  }
+
+  private fun <T : Event<T>> sendEventForDirectEvent(event: T) {
+    // Delivers the event to JS as a direct event. This method is called only on Paper.
+    reactApplicationContext.dispatchEvent(event)
+  }
+
+  private fun sendEventForDeviceEvent(eventName: String, data: WritableMap) {
+    // Delivers the event to JS as a device event.
+    reactApplicationContext.deviceEventEmitter.emit(eventName, data)
+  }
+}

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

@@ -0,0 +1,34 @@
+package com.swmansion.gesturehandler.react
+
+import com.swmansion.gesturehandler.core.FlingGestureHandler
+import com.swmansion.gesturehandler.core.GestureHandler
+import com.swmansion.gesturehandler.core.HoverGestureHandler
+import com.swmansion.gesturehandler.core.LongPressGestureHandler
+import com.swmansion.gesturehandler.core.ManualGestureHandler
+import com.swmansion.gesturehandler.core.NativeViewGestureHandler
+import com.swmansion.gesturehandler.core.PanGestureHandler
+import com.swmansion.gesturehandler.core.PinchGestureHandler
+import com.swmansion.gesturehandler.core.RotationGestureHandler
+import com.swmansion.gesturehandler.core.TapGestureHandler
+
+object RNGestureHandlerFactoryUtil {
+  private val handlerFactories = arrayOf<GestureHandler.Factory<*>>(
+    NativeViewGestureHandler.Factory(),
+    TapGestureHandler.Factory(),
+    LongPressGestureHandler.Factory(),
+    PanGestureHandler.Factory(),
+    PinchGestureHandler.Factory(),
+    RotationGestureHandler.Factory(),
+    FlingGestureHandler.Factory(),
+    ManualGestureHandler.Factory(),
+    HoverGestureHandler.Factory(),
+  )
+
+  @Suppress("UNCHECKED_CAST")
+  fun <T : GestureHandler> findFactoryForHandler(handler: GestureHandler): GestureHandler.Factory<GestureHandler>? =
+    handlerFactories.firstOrNull { it.type == handler.javaClass } as GestureHandler.Factory<GestureHandler>?
+
+  @Suppress("UNCHECKED_CAST")
+  fun <T : GestureHandler> findFactoryForName(handlerName: String): GestureHandler.Factory<GestureHandler>? =
+    handlerFactories.firstOrNull { it.name == handlerName } as GestureHandler.Factory<GestureHandler>?
+}

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

@@ -25,7 +25,7 @@ class RNGestureHandlerInteractionManager : GestureHandlerInteractionController {
     }
   }
 
-  fun configureInteractions(handler: GestureHandler<*>, config: ReadableMap) {
+  fun configureInteractions(handler: GestureHandler, config: ReadableMap) {
     handler.setInteractionController(this)
     if (config.hasKey(KEY_WAIT_FOR)) {
       val tags = convertHandlerTagsArray(config, KEY_WAIT_FOR)
@@ -41,15 +41,13 @@ class RNGestureHandlerInteractionManager : GestureHandlerInteractionController {
     }
   }
 
-  override fun shouldWaitForHandlerFailure(handler: GestureHandler<*>, otherHandler: GestureHandler<*>) =
+  override fun shouldWaitForHandlerFailure(handler: GestureHandler, otherHandler: GestureHandler) =
     waitForRelations[handler.tag]?.any { tag -> tag == otherHandler.tag } ?: false
 
-  override fun shouldRequireHandlerToWaitForFailure(
-    handler: GestureHandler<*>,
-    otherHandler: GestureHandler<*>,
-  ) = blockingRelations[handler.tag]?.any { tag -> tag == otherHandler.tag } ?: false
+  override fun shouldRequireHandlerToWaitForFailure(handler: GestureHandler, otherHandler: GestureHandler) =
+    blockingRelations[handler.tag]?.any { tag -> tag == otherHandler.tag } ?: false
 
-  override fun shouldHandlerBeCancelledBy(handler: GestureHandler<*>, otherHandler: GestureHandler<*>): Boolean {
+  override fun shouldHandlerBeCancelledBy(handler: GestureHandler, otherHandler: GestureHandler): Boolean {
     if (otherHandler is NativeViewGestureHandler) {
       return otherHandler.disallowInterruption
     }
@@ -60,10 +58,8 @@ class RNGestureHandlerInteractionManager : GestureHandlerInteractionController {
 
     return false
   }
-  override fun shouldRecognizeSimultaneously(
-    handler: GestureHandler<*>,
-    otherHandler: GestureHandler<*>,
-  ) = simultaneousRelations[handler.tag]?.any { tag -> tag == otherHandler.tag } ?: false
+  override fun shouldRecognizeSimultaneously(handler: GestureHandler, otherHandler: GestureHandler) =
+    simultaneousRelations[handler.tag]?.any { tag -> tag == otherHandler.tag } ?: false
 
   fun reset() {
     waitForRelations.clear()