@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1 → 2.12.6-1

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

@@ -1,702 +0,0 @@
-package com.swmansion.gesturehandler.react
-
-import android.content.Context
-import android.util.Log
-import android.view.MotionEvent
-import com.facebook.react.ReactRootView
-import com.facebook.react.bridge.JSApplicationIllegalArgumentException
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.ReadableType
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.uimanager.PixelUtil
-import com.facebook.react.uimanager.events.Event
-import com.facebook.soloader.SoLoader
-import com.swmansion.common.GestureHandlerStateManager
-import com.swmansion.gesturehandler.BuildConfig
-import com.swmansion.gesturehandler.ReanimatedEventDispatcher
-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.OnTouchEventListener
-import com.swmansion.gesturehandler.core.PanGestureHandler
-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
-
-// UIManagerModule.resolveRootTagFromReactTag() was deprecated and will be removed in the next RN release
-// ref: https://github.com/facebook/react-native/commit/acbf9e18ea666b07c1224a324602a41d0a66985e
-@Suppress("DEPRECATION")
-@ReactModule(name = RNGestureHandlerModule.MODULE_NAME)
-class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
-  ReactContextBaseJavaModule(reactContext), GestureHandlerStateManager {
-  private abstract class HandlerFactory<T : GestureHandler<T>> {
-    abstract val type: Class<T>
-    abstract val name: String
-    abstract fun create(context: Context?): T
-    open fun configure(handler: T, config: ReadableMap) {
-      handler.resetConfig()
-      if (config.hasKey(KEY_SHOULD_CANCEL_WHEN_OUTSIDE)) {
-        handler.setShouldCancelWhenOutside(config.getBoolean(KEY_SHOULD_CANCEL_WHEN_OUTSIDE))
-      }
-      if (config.hasKey(KEY_ENABLED)) {
-        handler.setEnabled(config.getBoolean(KEY_ENABLED))
-      }
-      if (config.hasKey(KEY_HIT_SLOP)) {
-        handleHitSlopProperty(handler, config)
-      }
-      if (config.hasKey(KEY_NEEDS_POINTER_DATA)) {
-        handler.needsPointerData = config.getBoolean(KEY_NEEDS_POINTER_DATA)
-      }
-      if (config.hasKey(KEY_MANUAL_ACTIVATION)) {
-        handler.setManualActivation(config.getBoolean(KEY_MANUAL_ACTIVATION))
-      }
-    }
-
-    abstract fun createEventBuilder(handler: T): GestureHandlerEventDataBuilder<T>
-  }
-
-  private class NativeViewGestureHandlerFactory : HandlerFactory<NativeViewGestureHandler>() {
-    override val type = NativeViewGestureHandler::class.java
-    override val name = "NativeViewGestureHandler"
-
-    override fun create(context: Context?): NativeViewGestureHandler {
-      return NativeViewGestureHandler()
-    }
-
-    override fun configure(handler: NativeViewGestureHandler, config: ReadableMap) {
-      super.configure(handler, config)
-      if (config.hasKey(KEY_NATIVE_VIEW_SHOULD_ACTIVATE_ON_START)) {
-        handler.setShouldActivateOnStart(
-          config.getBoolean(KEY_NATIVE_VIEW_SHOULD_ACTIVATE_ON_START)
-        )
-      }
-      if (config.hasKey(KEY_NATIVE_VIEW_DISALLOW_INTERRUPTION)) {
-        handler.setDisallowInterruption(config.getBoolean(KEY_NATIVE_VIEW_DISALLOW_INTERRUPTION))
-      }
-    }
-
-    override fun createEventBuilder(handler: NativeViewGestureHandler) = NativeGestureHandlerEventDataBuilder(handler)
-  }
-
-  private class TapGestureHandlerFactory : HandlerFactory<TapGestureHandler>() {
-    override val type = TapGestureHandler::class.java
-    override val name = "TapGestureHandler"
-
-    override fun create(context: Context?): TapGestureHandler {
-      return TapGestureHandler()
-    }
-
-    override fun configure(handler: TapGestureHandler, config: ReadableMap) {
-      super.configure(handler, config)
-      if (config.hasKey(KEY_TAP_NUMBER_OF_TAPS)) {
-        handler.setNumberOfTaps(config.getInt(KEY_TAP_NUMBER_OF_TAPS))
-      }
-      if (config.hasKey(KEY_TAP_MAX_DURATION_MS)) {
-        handler.setMaxDurationMs(config.getInt(KEY_TAP_MAX_DURATION_MS).toLong())
-      }
-      if (config.hasKey(KEY_TAP_MAX_DELAY_MS)) {
-        handler.setMaxDelayMs(config.getInt(KEY_TAP_MAX_DELAY_MS).toLong())
-      }
-      if (config.hasKey(KEY_TAP_MAX_DELTA_X)) {
-        handler.setMaxDx(PixelUtil.toPixelFromDIP(config.getDouble(KEY_TAP_MAX_DELTA_X)))
-      }
-      if (config.hasKey(KEY_TAP_MAX_DELTA_Y)) {
-        handler.setMaxDy(PixelUtil.toPixelFromDIP(config.getDouble(KEY_TAP_MAX_DELTA_Y)))
-      }
-      if (config.hasKey(KEY_TAP_MAX_DIST)) {
-        handler.setMaxDist(PixelUtil.toPixelFromDIP(config.getDouble(KEY_TAP_MAX_DIST)))
-      }
-      if (config.hasKey(KEY_TAP_MIN_POINTERS)) {
-        handler.setMinNumberOfPointers(config.getInt(KEY_TAP_MIN_POINTERS))
-      }
-    }
-
-    override fun createEventBuilder(handler: TapGestureHandler) = TapGestureHandlerEventDataBuilder(handler)
-  }
-
-  private class LongPressGestureHandlerFactory : HandlerFactory<LongPressGestureHandler>() {
-    override val type = LongPressGestureHandler::class.java
-    override val name = "LongPressGestureHandler"
-
-    override fun create(context: Context?): LongPressGestureHandler {
-      return LongPressGestureHandler((context)!!)
-    }
-
-    override fun configure(handler: LongPressGestureHandler, config: ReadableMap) {
-      super.configure(handler, config)
-      if (config.hasKey(KEY_LONG_PRESS_MIN_DURATION_MS)) {
-        handler.minDurationMs = config.getInt(KEY_LONG_PRESS_MIN_DURATION_MS).toLong()
-      }
-      if (config.hasKey(KEY_LONG_PRESS_MAX_DIST)) {
-        handler.setMaxDist(PixelUtil.toPixelFromDIP(config.getDouble(KEY_LONG_PRESS_MAX_DIST)))
-      }
-    }
-
-    override fun createEventBuilder(handler: LongPressGestureHandler) = LongPressGestureHandlerEventDataBuilder(handler)
-  }
-
-  private class PanGestureHandlerFactory : HandlerFactory<PanGestureHandler>() {
-    override val type = PanGestureHandler::class.java
-    override val name = "PanGestureHandler"
-
-    override fun create(context: Context?): PanGestureHandler {
-      return PanGestureHandler(context)
-    }
-
-    override fun configure(handler: PanGestureHandler, config: ReadableMap) {
-      super.configure(handler, config)
-      var hasCustomActivationCriteria = false
-      if (config.hasKey(KEY_PAN_ACTIVE_OFFSET_X_START)) {
-        handler.setActiveOffsetXStart(PixelUtil.toPixelFromDIP(config.getDouble(KEY_PAN_ACTIVE_OFFSET_X_START)))
-        hasCustomActivationCriteria = true
-      }
-      if (config.hasKey(KEY_PAN_ACTIVE_OFFSET_X_END)) {
-        handler.setActiveOffsetXEnd(PixelUtil.toPixelFromDIP(config.getDouble(KEY_PAN_ACTIVE_OFFSET_X_END)))
-        hasCustomActivationCriteria = true
-      }
-      if (config.hasKey(KEY_PAN_FAIL_OFFSET_RANGE_X_START)) {
-        handler.setFailOffsetXStart(PixelUtil.toPixelFromDIP(config.getDouble(KEY_PAN_FAIL_OFFSET_RANGE_X_START)))
-        hasCustomActivationCriteria = true
-      }
-      if (config.hasKey(KEY_PAN_FAIL_OFFSET_RANGE_X_END)) {
-        handler.setFailOffsetXEnd(PixelUtil.toPixelFromDIP(config.getDouble(KEY_PAN_FAIL_OFFSET_RANGE_X_END)))
-        hasCustomActivationCriteria = true
-      }
-      if (config.hasKey(KEY_PAN_ACTIVE_OFFSET_Y_START)) {
-        handler.setActiveOffsetYStart(PixelUtil.toPixelFromDIP(config.getDouble(KEY_PAN_ACTIVE_OFFSET_Y_START)))
-        hasCustomActivationCriteria = true
-      }
-      if (config.hasKey(KEY_PAN_ACTIVE_OFFSET_Y_END)) {
-        handler.setActiveOffsetYEnd(PixelUtil.toPixelFromDIP(config.getDouble(KEY_PAN_ACTIVE_OFFSET_Y_END)))
-        hasCustomActivationCriteria = true
-      }
-      if (config.hasKey(KEY_PAN_FAIL_OFFSET_RANGE_Y_START)) {
-        handler.setFailOffsetYStart(PixelUtil.toPixelFromDIP(config.getDouble(KEY_PAN_FAIL_OFFSET_RANGE_Y_START)))
-        hasCustomActivationCriteria = true
-      }
-      if (config.hasKey(KEY_PAN_FAIL_OFFSET_RANGE_Y_END)) {
-        handler.setFailOffsetYEnd(PixelUtil.toPixelFromDIP(config.getDouble(KEY_PAN_FAIL_OFFSET_RANGE_Y_END)))
-        hasCustomActivationCriteria = true
-      }
-      if (config.hasKey(KEY_PAN_MIN_VELOCITY)) {
-        // This value is actually in DPs/ms, but we can use the same function as for converting
-        // from DPs to pixels as the unit we're converting is in the numerator
-        handler.setMinVelocity(PixelUtil.toPixelFromDIP(config.getDouble(KEY_PAN_MIN_VELOCITY)))
-        hasCustomActivationCriteria = true
-      }
-      if (config.hasKey(KEY_PAN_MIN_VELOCITY_X)) {
-        handler.setMinVelocityX(PixelUtil.toPixelFromDIP(config.getDouble(KEY_PAN_MIN_VELOCITY_X)))
-        hasCustomActivationCriteria = true
-      }
-      if (config.hasKey(KEY_PAN_MIN_VELOCITY_Y)) {
-        handler.setMinVelocityY(PixelUtil.toPixelFromDIP(config.getDouble(KEY_PAN_MIN_VELOCITY_Y)))
-        hasCustomActivationCriteria = true
-      }
-
-      // PanGestureHandler sets minDist by default, if there are custom criteria specified we want
-      // to reset that setting and use provided criteria instead.
-      if (config.hasKey(KEY_PAN_MIN_DIST)) {
-        handler.setMinDist(PixelUtil.toPixelFromDIP(config.getDouble(KEY_PAN_MIN_DIST)))
-      } else if (hasCustomActivationCriteria) {
-        handler.setMinDist(Float.MAX_VALUE)
-      }
-      if (config.hasKey(KEY_PAN_MIN_POINTERS)) {
-        handler.setMinPointers(config.getInt(KEY_PAN_MIN_POINTERS))
-      }
-      if (config.hasKey(KEY_PAN_MAX_POINTERS)) {
-        handler.setMaxPointers(config.getInt(KEY_PAN_MAX_POINTERS))
-      }
-      if (config.hasKey(KEY_PAN_AVG_TOUCHES)) {
-        handler.setAverageTouches(config.getBoolean(KEY_PAN_AVG_TOUCHES))
-      }
-      if (config.hasKey(KEY_PAN_ACTIVATE_AFTER_LONG_PRESS)) {
-        handler.setActivateAfterLongPress(config.getInt(KEY_PAN_ACTIVATE_AFTER_LONG_PRESS).toLong())
-      }
-    }
-
-    override fun createEventBuilder(handler: PanGestureHandler) = PanGestureHandlerEventDataBuilder(handler)
-  }
-
-  private class PinchGestureHandlerFactory : HandlerFactory<PinchGestureHandler>() {
-    override val type = PinchGestureHandler::class.java
-    override val name = "PinchGestureHandler"
-
-    override fun create(context: Context?): PinchGestureHandler {
-      return PinchGestureHandler()
-    }
-
-    override fun createEventBuilder(handler: PinchGestureHandler) = PinchGestureHandlerEventDataBuilder(handler)
-  }
-
-  private class FlingGestureHandlerFactory : HandlerFactory<FlingGestureHandler>() {
-    override val type = FlingGestureHandler::class.java
-    override val name = "FlingGestureHandler"
-
-    override fun create(context: Context?): FlingGestureHandler {
-      return FlingGestureHandler()
-    }
-
-    override fun configure(handler: FlingGestureHandler, config: ReadableMap) {
-      super.configure(handler, config)
-      if (config.hasKey(KEY_NUMBER_OF_POINTERS)) {
-        handler.numberOfPointersRequired = config.getInt(KEY_NUMBER_OF_POINTERS)
-      }
-      if (config.hasKey(KEY_DIRECTION)) {
-        handler.direction = config.getInt(KEY_DIRECTION)
-      }
-    }
-
-    override fun createEventBuilder(handler: FlingGestureHandler) = FlingGestureHandlerEventDataBuilder(handler)
-  }
-
-  private class RotationGestureHandlerFactory : HandlerFactory<RotationGestureHandler>() {
-    override val type = RotationGestureHandler::class.java
-    override val name = "RotationGestureHandler"
-
-    override fun create(context: Context?): RotationGestureHandler {
-      return RotationGestureHandler()
-    }
-
-    override fun createEventBuilder(handler: RotationGestureHandler) = RotationGestureHandlerEventDataBuilder(handler)
-  }
-
-  private class ManualGestureHandlerFactory : HandlerFactory<ManualGestureHandler>() {
-    override val type = ManualGestureHandler::class.java
-    override val name = "ManualGestureHandler"
-
-    override fun create(context: Context?): ManualGestureHandler {
-      return ManualGestureHandler()
-    }
-
-    override fun createEventBuilder(handler: ManualGestureHandler) = ManualGestureHandlerEventDataBuilder(handler)
-  }
-
-  private class HoverGestureHandlerFactory : HandlerFactory<HoverGestureHandler>() {
-    override val type = HoverGestureHandler::class.java
-    override val name = "HoverGestureHandler"
-
-    override fun create(context: Context?): HoverGestureHandler {
-      return HoverGestureHandler()
-    }
-
-    override fun createEventBuilder(handler: HoverGestureHandler) = HoverGestureHandlerEventDataBuilder(handler)
-  }
-
-  private val eventListener = object : OnTouchEventListener {
-    override fun <T : GestureHandler<T>> onHandlerUpdate(handler: T, event: MotionEvent) {
-      this@RNGestureHandlerModule.onHandlerUpdate(handler)
-    }
-
-    override fun <T : GestureHandler<T>> onStateChange(handler: T, newState: Int, oldState: Int) {
-      this@RNGestureHandlerModule.onStateChange(handler, newState, oldState)
-    }
-
-    override fun <T : GestureHandler<T>> onTouchEvent(handler: T) {
-      this@RNGestureHandlerModule.onTouchEvent(handler)
-    }
-  }
-  private val handlerFactories = arrayOf<HandlerFactory<*>>(
-    NativeViewGestureHandlerFactory(),
-    TapGestureHandlerFactory(),
-    LongPressGestureHandlerFactory(),
-    PanGestureHandlerFactory(),
-    PinchGestureHandlerFactory(),
-    RotationGestureHandlerFactory(),
-    FlingGestureHandlerFactory(),
-    ManualGestureHandlerFactory(),
-    HoverGestureHandlerFactory(),
-  )
-  val registry: RNGestureHandlerRegistry = RNGestureHandlerRegistry()
-  private val interactionManager = RNGestureHandlerInteractionManager()
-  private val roots: MutableList<RNGestureHandlerRootHelper> = ArrayList()
-  private val reanimatedEventDispatcher = ReanimatedEventDispatcher()
-  override fun getName() = MODULE_NAME
-
-  @ReactMethod
-  @Suppress("UNCHECKED_CAST")
-  fun <T : GestureHandler<T>> createGestureHandler(
-    handlerName: String,
-    handlerTag: Int,
-    config: ReadableMap,
-  ) {
-    for (handlerFactory in handlerFactories as Array<HandlerFactory<T>>) {
-      if (handlerFactory.name == handlerName) {
-        val handler = handlerFactory.create(reactApplicationContext).apply {
-          tag = handlerTag
-          setOnTouchEventListener(eventListener)
-        }
-        registry.registerHandler(handler)
-        interactionManager.configureInteractions(handler, config)
-        handlerFactory.configure(handler, config)
-        return
-      }
-    }
-    throw JSApplicationIllegalArgumentException("Invalid handler name $handlerName")
-  }
-
-  @ReactMethod
-  fun attachGestureHandler(handlerTag: Int, viewTag: Int, actionType: Int) {
-    // We don't have to handle view flattening in any special way since handlers are stored as
-    // a map: viewTag -> [handler]. If the view with attached handlers was to be flattened
-    // then that viewTag simply wouldn't be visited when traversing the view hierarchy in the
-    // Orchestrator effectively ignoring all handlers attached to flattened views.
-    if (!registry.attachHandlerToView(handlerTag, viewTag, actionType)) {
-      throw JSApplicationIllegalArgumentException("Handler with tag $handlerTag does not exists")
-    }
-  }
-
-  @ReactMethod
-  @Suppress("UNCHECKED_CAST")
-  fun <T : GestureHandler<T>> updateGestureHandler(handlerTag: Int, config: ReadableMap) {
-    val handler = registry.getHandler(handlerTag) as T?
-    if (handler != null) {
-      val factory = findFactoryForHandler(handler)
-      if (factory != null) {
-        interactionManager.dropRelationsForHandlerWithTag(handlerTag)
-        interactionManager.configureInteractions(handler, config)
-        factory.configure(handler, config)
-      }
-    }
-  }
-
-  @ReactMethod
-  fun dropGestureHandler(handlerTag: Int) {
-    interactionManager.dropRelationsForHandlerWithTag(handlerTag)
-    registry.dropHandler(handlerTag)
-  }
-
-  @ReactMethod
-  fun handleSetJSResponder(viewTag: Int, blockNativeResponder: Boolean) {
-    val rootView = findRootHelperForViewAncestor(viewTag)
-    rootView?.handleSetJSResponder(viewTag, blockNativeResponder)
-  }
-
-  @ReactMethod
-  fun handleClearJSResponder() {
-  }
-
-  override fun setGestureHandlerState(handlerTag: Int, newState: Int) {
-    registry.getHandler(handlerTag)?.let { handler ->
-      when (newState) {
-        GestureHandler.STATE_ACTIVE -> handler.activate(force = true)
-        GestureHandler.STATE_BEGAN -> handler.begin()
-        GestureHandler.STATE_END -> handler.end()
-        GestureHandler.STATE_FAILED -> handler.fail()
-        GestureHandler.STATE_CANCELLED -> handler.cancel()
-      }
-    }
-  }
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  fun install(): Boolean {
-    return try {
-      SoLoader.loadLibrary("gesturehandler")
-      val jsContext = reactApplicationContext.javaScriptContextHolder!!
-      decorateRuntime(jsContext.get())
-      true
-    } catch (exception: Exception) {
-      Log.w("[RNGestureHandler]", "Could not install JSI bindings.")
-      false
-    }
-  }
-
-  private external fun decorateRuntime(jsiPtr: Long)
-
-  override fun getConstants(): Map<String, Any> {
-    return mapOf(
-      "State" to mapOf(
-        "UNDETERMINED" to GestureHandler.STATE_UNDETERMINED,
-        "BEGAN" to GestureHandler.STATE_BEGAN,
-        "ACTIVE" to GestureHandler.STATE_ACTIVE,
-        "CANCELLED" to GestureHandler.STATE_CANCELLED,
-        "FAILED" to GestureHandler.STATE_FAILED,
-        "END" to GestureHandler.STATE_END
-      ),
-      "Direction" to mapOf(
-        "RIGHT" to GestureHandler.DIRECTION_RIGHT,
-        "LEFT" to GestureHandler.DIRECTION_LEFT,
-        "UP" to GestureHandler.DIRECTION_UP,
-        "DOWN" to GestureHandler.DIRECTION_DOWN
-      )
-    )
-  }
-
-  override fun onCatalystInstanceDestroy() {
-    registry.dropAllHandlers()
-    interactionManager.reset()
-    synchronized(roots) {
-      while (roots.isNotEmpty()) {
-        val sizeBefore: Int = roots.size
-        val root: RNGestureHandlerRootHelper = roots[0]
-        root.tearDown()
-        if (roots.size >= sizeBefore) {
-          throw IllegalStateException("Expected root helper to get unregistered while tearing down")
-        }
-      }
-    }
-    super.onCatalystInstanceDestroy()
-  }
-
-  fun registerRootHelper(root: RNGestureHandlerRootHelper) {
-    synchronized(roots) {
-      if (root in roots) {
-        throw IllegalStateException("Root helper$root already registered")
-      }
-      roots.add(root)
-    }
-  }
-
-  fun unregisterRootHelper(root: RNGestureHandlerRootHelper) {
-    synchronized(roots) { roots.remove(root) }
-  }
-
-  private fun findRootHelperForViewAncestor(viewTag: Int): RNGestureHandlerRootHelper? {
-    // TODO: remove resolveRootTagFromReactTag as it's deprecated and unavailable on FabricUIManager
-    val uiManager = reactApplicationContext.UIManager
-    val rootViewTag = uiManager.resolveRootTagFromReactTag(viewTag)
-    if (rootViewTag < 1) {
-      return null
-    }
-    synchronized(roots) {
-      return roots.firstOrNull {
-        it.rootView is ReactRootView && it.rootView.rootViewTag == rootViewTag
-      }
-    }
-  }
-
-  @Suppress("UNCHECKED_CAST")
-  private fun <T : GestureHandler<T>> findFactoryForHandler(handler: GestureHandler<T>): HandlerFactory<T>? =
-    handlerFactories.firstOrNull { it.type == handler.javaClass } as HandlerFactory<T>?
-
-  private fun <T : GestureHandler<T>> onHandlerUpdate(handler: T) {
-    // triggers onUpdate and onChange 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_ACTIVE) {
-      val handlerFactory = findFactoryForHandler(handler) ?: return
-
-      if (handler.actionType == GestureHandler.ACTION_TYPE_REANIMATED_WORKLET) {
-        // Reanimated worklet
-        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.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(handlerFactory.createEventBuilder(handler))
-          sendEventForDeviceEvent(RNGestureHandlerEvent.EVENT_NAME, data)
-        } else {
-          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(handlerFactory.createEventBuilder(handler))
-        sendEventForDeviceEvent(RNGestureHandlerEvent.EVENT_NAME, data)
-      }
-    }
-  }
-
-  private fun <T : GestureHandler<T>> onStateChange(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 = findFactoryForHandler(handler) ?: return
-
-    if (handler.actionType == GestureHandler.ACTION_TYPE_REANIMATED_WORKLET) {
-      // Reanimated worklet
-      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(handlerFactory.createEventBuilder(handler), newState, oldState)
-        sendEventForDeviceEvent(RNGestureHandlerStateChangeEvent.EVENT_NAME, data)
-      } else {
-        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(handlerFactory.createEventBuilder(handler), newState, oldState)
-      sendEventForDeviceEvent(RNGestureHandlerStateChangeEvent.EVENT_NAME, data)
-    }
-  }
-
-  private fun <T : GestureHandler<T>> onTouchEvent(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
-    ) {
-      if (handler.actionType == GestureHandler.ACTION_TYPE_REANIMATED_WORKLET) {
-        // Reanimated worklet
-        val event = RNGestureHandlerTouchEvent.obtain(handler)
-        sendEventForReanimated(event)
-      } else if (handler.actionType == 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)
-  }
-
-  companion object {
-    const val MODULE_NAME = "RNGestureHandlerModule"
-    private const val KEY_SHOULD_CANCEL_WHEN_OUTSIDE = "shouldCancelWhenOutside"
-    private const val KEY_ENABLED = "enabled"
-    private const val KEY_NEEDS_POINTER_DATA = "needsPointerData"
-    private const val KEY_MANUAL_ACTIVATION = "manualActivation"
-    private const val KEY_HIT_SLOP = "hitSlop"
-    private const val KEY_HIT_SLOP_LEFT = "left"
-    private const val KEY_HIT_SLOP_TOP = "top"
-    private const val KEY_HIT_SLOP_RIGHT = "right"
-    private const val KEY_HIT_SLOP_BOTTOM = "bottom"
-    private const val KEY_HIT_SLOP_VERTICAL = "vertical"
-    private const val KEY_HIT_SLOP_HORIZONTAL = "horizontal"
-    private const val KEY_HIT_SLOP_WIDTH = "width"
-    private const val KEY_HIT_SLOP_HEIGHT = "height"
-    private const val KEY_NATIVE_VIEW_SHOULD_ACTIVATE_ON_START = "shouldActivateOnStart"
-    private const val KEY_NATIVE_VIEW_DISALLOW_INTERRUPTION = "disallowInterruption"
-    private const val KEY_TAP_NUMBER_OF_TAPS = "numberOfTaps"
-    private const val KEY_TAP_MAX_DURATION_MS = "maxDurationMs"
-    private const val KEY_TAP_MAX_DELAY_MS = "maxDelayMs"
-    private const val KEY_TAP_MAX_DELTA_X = "maxDeltaX"
-    private const val KEY_TAP_MAX_DELTA_Y = "maxDeltaY"
-    private const val KEY_TAP_MAX_DIST = "maxDist"
-    private const val KEY_TAP_MIN_POINTERS = "minPointers"
-    private const val KEY_LONG_PRESS_MIN_DURATION_MS = "minDurationMs"
-    private const val KEY_LONG_PRESS_MAX_DIST = "maxDist"
-    private const val KEY_PAN_ACTIVE_OFFSET_X_START = "activeOffsetXStart"
-    private const val KEY_PAN_ACTIVE_OFFSET_X_END = "activeOffsetXEnd"
-    private const val KEY_PAN_FAIL_OFFSET_RANGE_X_START = "failOffsetXStart"
-    private const val KEY_PAN_FAIL_OFFSET_RANGE_X_END = "failOffsetXEnd"
-    private const val KEY_PAN_ACTIVE_OFFSET_Y_START = "activeOffsetYStart"
-    private const val KEY_PAN_ACTIVE_OFFSET_Y_END = "activeOffsetYEnd"
-    private const val KEY_PAN_FAIL_OFFSET_RANGE_Y_START = "failOffsetYStart"
-    private const val KEY_PAN_FAIL_OFFSET_RANGE_Y_END = "failOffsetYEnd"
-    private const val KEY_PAN_MIN_DIST = "minDist"
-    private const val KEY_PAN_MIN_VELOCITY = "minVelocity"
-    private const val KEY_PAN_MIN_VELOCITY_X = "minVelocityX"
-    private const val KEY_PAN_MIN_VELOCITY_Y = "minVelocityY"
-    private const val KEY_PAN_MIN_POINTERS = "minPointers"
-    private const val KEY_PAN_MAX_POINTERS = "maxPointers"
-    private const val KEY_PAN_AVG_TOUCHES = "avgTouches"
-    private const val KEY_PAN_ACTIVATE_AFTER_LONG_PRESS = "activateAfterLongPress"
-    private const val KEY_NUMBER_OF_POINTERS = "numberOfPointers"
-    private const val KEY_DIRECTION = "direction"
-
-    private fun handleHitSlopProperty(handler: GestureHandler<*>, config: ReadableMap) {
-      if (config.getType(KEY_HIT_SLOP) == ReadableType.Number) {
-        val hitSlop = PixelUtil.toPixelFromDIP(config.getDouble(KEY_HIT_SLOP))
-        handler.setHitSlop(hitSlop, hitSlop, hitSlop, hitSlop, GestureHandler.HIT_SLOP_NONE, GestureHandler.HIT_SLOP_NONE)
-      } else {
-        val hitSlop = config.getMap(KEY_HIT_SLOP)!!
-        var left = GestureHandler.HIT_SLOP_NONE
-        var top = GestureHandler.HIT_SLOP_NONE
-        var right = GestureHandler.HIT_SLOP_NONE
-        var bottom = GestureHandler.HIT_SLOP_NONE
-        var width = GestureHandler.HIT_SLOP_NONE
-        var height = GestureHandler.HIT_SLOP_NONE
-        if (hitSlop.hasKey(KEY_HIT_SLOP_HORIZONTAL)) {
-          val horizontalPad = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_HORIZONTAL))
-          right = horizontalPad
-          left = right
-        }
-        if (hitSlop.hasKey(KEY_HIT_SLOP_VERTICAL)) {
-          val verticalPad = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_VERTICAL))
-          bottom = verticalPad
-          top = bottom
-        }
-        if (hitSlop.hasKey(KEY_HIT_SLOP_LEFT)) {
-          left = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_LEFT))
-        }
-        if (hitSlop.hasKey(KEY_HIT_SLOP_TOP)) {
-          top = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_TOP))
-        }
-        if (hitSlop.hasKey(KEY_HIT_SLOP_RIGHT)) {
-          right = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_RIGHT))
-        }
-        if (hitSlop.hasKey(KEY_HIT_SLOP_BOTTOM)) {
-          bottom = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_BOTTOM))
-        }
-        if (hitSlop.hasKey(KEY_HIT_SLOP_WIDTH)) {
-          width = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_WIDTH))
-        }
-        if (hitSlop.hasKey(KEY_HIT_SLOP_HEIGHT)) {
-          height = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_HEIGHT))
-        }
-        handler.setHitSlop(left, top, right, bottom, width, height)
-      }
-    }
-  }
-}