react-native-gesture-handler 2.14.1 → 2.16.0-rc.0

package/README.md

@@ -39,6 +39,7 @@ You will need to have an Android or iOS device or emulator connected as well as
 
 | version | react-native version |
 | ------- | -------------------- |
+| 2.14.0+ | 0.67.0+              |
 | 2.10.0+ | 0.64.0+              |
 | 2.0.0+  | 0.63.0+              |
 | 1.4.0+  | 0.60.0+              |

package/RNGestureHandler.podspec

@@ -1,8 +1,5 @@
 require "json"
 
-new_arch_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
-apple_platform = new_arch_enabled ? '11.0' : '9.0'
-
 Pod::Spec.new do |s|
   # NPM package specification
   package = JSON.parse(File.read(File.join(File.dirname(__FILE__), "package.json")))
@@ -14,31 +11,13 @@ Pod::Spec.new do |s|
   s.license      = "MIT"
   s.author       = { package["author"]["name"] => package["author"]["email"] }
   s.source       = { :git => "https://github.com/software-mansion/react-native-gesture-handler", :tag => "#{s.version}" }
-  s.source_files = "ios/**/*.{h,m,mm}"
+  s.source_files = "apple/**/*.{h,m,mm}"
   s.requires_arc = true
-  s.platforms       = { ios: apple_platform, tvos: apple_platform }
+  s.platforms       = { ios: '11.0', tvos: '11.0', osx: '10.15', visionos: '1.0' }
 
   if defined?(install_modules_dependencies()) != nil
     install_modules_dependencies(s);
   else
-    if new_arch_enabled
-      folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
-  
-      s.pod_target_xcconfig = {
-        'HEADER_SEARCH_PATHS' => '"$(PODS_ROOT)/boost" "$(PODS_ROOT)/boost-for-react-native" "$(PODS_ROOT)/RCT-Folly"',
-        'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
-      }
-      s.compiler_flags  = folly_compiler_flags + ' -DRCT_NEW_ARCH_ENABLED'
-  
-      s.dependency "React"
-      s.dependency "React-RCTFabric" # This is for fabric component
-      s.dependency "React-Codegen"
-      s.dependency "RCT-Folly"
-      s.dependency "RCTRequired"
-      s.dependency "RCTTypeSafety"
-      s.dependency "ReactCommon/turbomodule/core"
-    else
-      s.dependency "React-Core"
-    end
+    s.dependency "React-Core"
   end
 end

package/android/build.gradle

@@ -136,7 +136,7 @@ android {
             var appProject = rootProject.allprojects.find {it.plugins.hasPlugin('com.android.application')}
             externalNativeBuild {
                 cmake {
-                    cppFlags "-O2", "-frtti", "-fexceptions", "-Wall", "-Werror", "-std=c++17", "-DANDROID"
+                    cppFlags "-O2", "-frtti", "-fexceptions", "-Wall", "-Werror", "-std=c++20", "-DANDROID"
                     arguments "-DAPP_BUILD_DIR=${appProject.buildDir}",
                         "-DREACT_NATIVE_DIR=${REACT_NATIVE_DIR}",
                         "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",

package/android/paper/src/main/java/com/swmansion/gesturehandler/NativeRNGestureHandlerModuleSpec.java

@@ -0,0 +1,55 @@
+package com.swmansion.gesturehandler;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+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.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+import com.facebook.react.bridge.ReactMethod;
+
+public abstract class NativeRNGestureHandlerModuleSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "RNGestureHandlerModule";
+
+  public NativeRNGestureHandlerModuleSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @DoNotStrip
+  @ReactMethod
+  public abstract void handleSetJSResponder(double tag, boolean blockNativeResponder);
+
+  @DoNotStrip
+  @ReactMethod
+  public abstract void handleClearJSResponder();
+
+  @DoNotStrip
+  @ReactMethod
+  public abstract void createGestureHandler(String handlerName, double handlerTag, ReadableMap config);
+
+  @DoNotStrip
+  @ReactMethod
+  public abstract void attachGestureHandler(double handlerTag, double newView, double actionType);
+
+  @DoNotStrip
+  @ReactMethod
+  public abstract void updateGestureHandler(double handlerTag, ReadableMap newConfig);
+
+  @DoNotStrip
+  @ReactMethod
+  public abstract void dropGestureHandler(double handlerTag);
+
+  @DoNotStrip
+  @ReactMethod
+  public abstract boolean install();
+
+  @DoNotStrip
+  @ReactMethod
+  public abstract void flushOperations();
+}

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

@@ -1,16 +1,34 @@
 package com.swmansion.gesturehandler
 
-import com.facebook.react.ReactPackage
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.ViewManagerOnDemandReactPackage
+import com.facebook.react.bridge.ModuleSpec
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.module.annotations.ReactModuleList
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
 import com.swmansion.gesturehandler.react.RNGestureHandlerButtonViewManager
 import com.swmansion.gesturehandler.react.RNGestureHandlerModule
 import com.swmansion.gesturehandler.react.RNGestureHandlerRootViewManager
 
-class RNGestureHandlerPackage : ReactPackage {
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf<NativeModule>(RNGestureHandlerModule(reactContext))
+@ReactModuleList(
+  nativeModules = [
+    RNGestureHandlerModule::class
+  ]
+)
+class RNGestureHandlerPackage : TurboReactPackage(), ViewManagerOnDemandReactPackage {
+  private val viewManagers: Map<String, ModuleSpec> by lazy {
+    mapOf(
+      RNGestureHandlerRootViewManager.REACT_CLASS to ModuleSpec.viewManagerSpec {
+        RNGestureHandlerRootViewManager()
+      },
+      RNGestureHandlerButtonViewManager.REACT_CLASS to ModuleSpec.viewManagerSpec {
+        RNGestureHandlerButtonViewManager()
+      }
+    )
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext) =
@@ -18,4 +36,51 @@ class RNGestureHandlerPackage : ReactPackage {
       RNGestureHandlerRootViewManager(),
       RNGestureHandlerButtonViewManager()
     )
+
+  override fun getViewManagerNames(reactContext: ReactApplicationContext?) =
+    viewManagers.keys.toList()
+
+  override fun getViewManagers(reactContext: ReactApplicationContext?): MutableList<ModuleSpec> =
+    viewManagers.values.toMutableList()
+
+  override fun createViewManager(
+    reactContext: ReactApplicationContext?,
+    viewManagerName: String?
+  ) = viewManagers[viewManagerName]?.provider?.get() as? ViewManager<*, *>
+
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == RNGestureHandlerModule.NAME) {
+      RNGestureHandlerModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    try {
+      val reactModuleInfoProviderClass =
+        Class.forName("com.swmansion.gesturehandler.RNGestureHandlerPackage$\$ReactModuleInfoProvider")
+      return reactModuleInfoProviderClass.newInstance() as ReactModuleInfoProvider
+    } catch (e: ClassNotFoundException) {
+      return ReactModuleInfoProvider {
+        val reactModule: ReactModule = RNGestureHandlerModule::class.java.getAnnotation(ReactModule::class.java)!!
+
+        mutableMapOf(
+          RNGestureHandlerModule.NAME to ReactModuleInfo(
+            reactModule.name,
+            RNGestureHandlerModule::class.java.name,
+            reactModule.canOverrideExistingModule,
+            reactModule.needsEagerInit,
+            reactModule.hasConstants,
+            reactModule.isCxxModule,
+            true
+          )
+        )
+      }
+    } catch (e: InstantiationException) {
+      throw RuntimeException("No ReactModuleInfoProvider for RNGestureHandlerPackage$\$ReactModuleInfoProvider", e)
+    } catch (e: IllegalAccessException) {
+      throw RuntimeException("No ReactModuleInfoProvider for RNGestureHandlerPackage$\$ReactModuleInfoProvider", e)
+    }
+  }
 }

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

@@ -67,6 +67,10 @@ class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (!shouldActivateWithMouse(sourceEvent)) {
+      return
+    }
+
     val state = state
     if (state == STATE_UNDETERMINED) {
       startFling(sourceEvent)

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

@@ -5,6 +5,7 @@ import android.content.Context
 import android.content.ContextWrapper
 import android.graphics.PointF
 import android.graphics.Rect
+import android.os.Build
 import android.view.MotionEvent
 import android.view.MotionEvent.PointerCoords
 import android.view.MotionEvent.PointerProperties
@@ -67,6 +68,10 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   protected var orchestrator: GestureHandlerOrchestrator? = null
   private var onTouchEventListener: OnTouchEventListener? = null
   private var interactionController: GestureHandlerInteractionController? = null
+  var pointerType: Int = POINTER_TYPE_OTHER
+    private set
+
+  protected var mouseButton = 0
 
   @Suppress("UNCHECKED_CAST")
   protected fun self(): ConcreteGestureHandlerT = this as ConcreteGestureHandlerT
@@ -159,6 +164,10 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   fun setInteractionController(controller: GestureHandlerInteractionController?): ConcreteGestureHandlerT =
     applySelf { interactionController = controller }
 
+  fun setMouseButton(mouseButton: Int) = apply {
+    this.mouseButton = mouseButton
+  }
+
   fun prepare(view: View?, orchestrator: GestureHandlerOrchestrator?) {
     check(!(this.view != null || this.orchestrator != null)) { "Already prepared or hasn't been reset" }
     Arrays.fill(trackedPointerIDs, -1)
@@ -371,6 +380,11 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     lastAbsolutePositionY = GestureUtils.getLastPointerY(adaptedTransformedEvent, true)
     lastEventOffsetX = adaptedTransformedEvent.rawX - adaptedTransformedEvent.x
     lastEventOffsetY = adaptedTransformedEvent.rawY - adaptedTransformedEvent.y
+
+    if (sourceEvent.action == MotionEvent.ACTION_DOWN || sourceEvent.action == MotionEvent.ACTION_HOVER_ENTER || sourceEvent.action == MotionEvent.ACTION_HOVER_MOVE) {
+      setPointerType(sourceEvent)
+    }
+
     if (sourceEvent.action == MotionEvent.ACTION_HOVER_ENTER ||
       sourceEvent.action == MotionEvent.ACTION_HOVER_MOVE ||
       sourceEvent.action == MotionEvent.ACTION_HOVER_EXIT
@@ -688,6 +702,46 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   protected open fun onReset() {}
   protected open fun onCancel() {}
 
+  private fun isButtonInConfig(clickedButton: Int): Boolean {
+    if (mouseButton == 0) {
+      return clickedButton == MotionEvent.BUTTON_PRIMARY
+    }
+
+    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).
+
+    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 (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN) {
+          return@shouldActivateWithMouse false
+        }
+
+        // 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
+        }
+
+        // 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
+        }
+      }
+    }
+
+    return true
+  }
+
   /**
    * Transforms a point in the coordinate space of the wrapperView (GestureHandlerRootView) to
    * coordinate space of the view the gesture is attached to.
@@ -721,6 +775,17 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     isWithinBounds = false
   }
 
+  private fun setPointerType(event: MotionEvent) {
+    val pointerIndex = event.actionIndex
+
+    pointerType = when (event.getToolType(pointerIndex)) {
+      MotionEvent.TOOL_TYPE_FINGER -> POINTER_TYPE_TOUCH
+      MotionEvent.TOOL_TYPE_STYLUS -> POINTER_TYPE_STYLUS
+      MotionEvent.TOOL_TYPE_MOUSE -> POINTER_TYPE_MOUSE
+      else -> POINTER_TYPE_OTHER
+    }
+  }
+
   fun setOnTouchEventListener(listener: OnTouchEventListener?): GestureHandler<*> {
     onTouchEventListener = listener
     return this
@@ -763,6 +828,10 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     const val ACTION_TYPE_NATIVE_ANIMATED_EVENT = 2
     const val ACTION_TYPE_JS_FUNCTION_OLD_API = 3
     const val ACTION_TYPE_JS_FUNCTION_NEW_API = 4
+    const val POINTER_TYPE_TOUCH = 0
+    const val POINTER_TYPE_STYLUS = 1
+    const val POINTER_TYPE_MOUSE = 2
+    const val POINTER_TYPE_OTHER = 3
     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

@@ -101,27 +101,33 @@ class GestureHandlerOrchestrator(
   fun onHandlerStateChange(handler: GestureHandler<*>, newState: Int, prevState: Int) {
     handlingChangeSemaphore += 1
     if (isFinished(newState)) {
+      // We have to loop through copy in order to avoid modifying collection
+      // while iterating over its elements
+      val currentlyAwaitingHandlers = awaitingHandlers.toList()
+
       // if there were handlers awaiting completion of this handler, we can trigger active state
-      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()
-            if (otherHandler.state == GestureHandler.STATE_END) {
-              // Handle edge case, where discrete gestures end immediately after activation thus
-              // their state is set to END and when the gesture they are waiting for activates they
-              // should be cancelled, however `cancel` was never sent as gestures were already in the END state.
-              // Send synthetic BEGAN -> CANCELLED to properly handle JS logic
-              otherHandler.dispatchStateChange(
-                GestureHandler.STATE_CANCELLED,
-                GestureHandler.STATE_BEGAN
-              )
-            }
-            otherHandler.isAwaiting = false
-          } else {
-            // gesture has failed recognition, we may try activating
-            tryActivate(otherHandler)
+      for (otherHandler in currentlyAwaitingHandlers) {
+        if (!shouldHandlerWaitForOther(otherHandler, handler)) {
+          continue
+        }
+
+        if (newState == GestureHandler.STATE_END) {
+          // gesture has ended, we need to kill the awaiting handler
+          otherHandler.cancel()
+          if (otherHandler.state == GestureHandler.STATE_END) {
+            // Handle edge case, where discrete gestures end immediately after activation thus
+            // their state is set to END and when the gesture they are waiting for activates they
+            // should be cancelled, however `cancel` was never sent as gestures were already in the END state.
+            // Send synthetic BEGAN -> CANCELLED to properly handle JS logic
+            otherHandler.dispatchStateChange(
+              GestureHandler.STATE_CANCELLED,
+              GestureHandler.STATE_BEGAN
+            )
           }
+          otherHandler.isAwaiting = false
+        } else {
+          // gesture has failed recognition, we may try activating
+          tryActivate(otherHandler)
         }
       }
       cleanupAwaitingHandlers()
@@ -174,9 +180,19 @@ class GestureHandlerOrchestrator(
     }
     cleanupAwaitingHandlers()
 
-    // Dispatch state change event if handler is no longer in the active state we should also
-    // trigger END state change and UNDETERMINED state change if necessary
+    // At this point the waiting handler is allowed to activate, so we need to send BEGAN -> ACTIVE event
+    // as it wasn't sent before. If handler has finished recognizing the gesture before it was allowed to
+    // activate, we also need to send ACTIVE -> END and END -> UNDETERMINED events, as it was blocked from
+    // sending events while waiting.
+    // There is one catch though - if the handler failed or was cancelled while waiting, relevant event has
+    // already been sent. The following chain would result in artificially activating that handler after the
+    // failure logic was ran and we don't want to do that.
+    if (currentState == GestureHandler.STATE_FAILED || currentState == GestureHandler.STATE_CANCELLED) {
+      return
+    }
+
     handler.dispatchStateChange(GestureHandler.STATE_ACTIVE, GestureHandler.STATE_BEGAN)
+
     if (currentState != GestureHandler.STATE_ACTIVE) {
       handler.dispatchStateChange(GestureHandler.STATE_END, GestureHandler.STATE_ACTIVE)
       if (currentState != GestureHandler.STATE_END) {

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

@@ -38,6 +38,10 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (!shouldActivateWithMouse(sourceEvent)) {
+      return
+    }
+
     if (state == STATE_UNDETERMINED) {
       previousTime = SystemClock.uptimeMillis()
       startTime = previousTime
@@ -51,7 +55,7 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
         activate()
       }
     }
-    if (sourceEvent.actionMasked == MotionEvent.ACTION_UP) {
+    if (sourceEvent.actionMasked == MotionEvent.ACTION_UP || sourceEvent.actionMasked == MotionEvent.ACTION_BUTTON_RELEASE) {
       handler?.let {
         it.removeCallbacksAndMessages(null)
         handler = null

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

@@ -208,6 +208,10 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (!shouldActivateWithMouse(sourceEvent)) {
+      return
+    }
+
     val state = state
     val action = sourceEvent.actionMasked
     if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN) {
@@ -246,7 +250,7 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       velocityX = velocityTracker!!.xVelocity
       velocityY = velocityTracker!!.yVelocity
     }
-    if (action == MotionEvent.ACTION_UP) {
+    if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_BUTTON_RELEASE) {
       if (state == STATE_ACTIVE) {
         end()
       } else {

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

@@ -105,6 +105,10 @@ class TapGestureHandler : GestureHandler<TapGestureHandler>() {
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (!shouldActivateWithMouse(sourceEvent)) {
+      return
+    }
+
     val state = state
     val action = sourceEvent.actionMasked
     if (state == STATE_UNDETERMINED) {
@@ -130,14 +134,14 @@ class TapGestureHandler : GestureHandler<TapGestureHandler>() {
     if (shouldFail()) {
       fail()
     } else if (state == STATE_UNDETERMINED) {
-      if (action == MotionEvent.ACTION_DOWN) {
+      if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_BUTTON_PRESS) {
         begin()
       }
       startTap()
     } else if (state == STATE_BEGAN) {
-      if (action == MotionEvent.ACTION_UP) {
+      if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_BUTTON_RELEASE) {
         endTap()
-      } else if (action == MotionEvent.ACTION_DOWN) {
+      } else if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_BUTTON_PRESS) {
         startTap()
       }
     }

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

@@ -6,7 +6,6 @@ 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
@@ -17,6 +16,7 @@ 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.NativeRNGestureHandlerModuleSpec
 import com.swmansion.gesturehandler.ReanimatedEventDispatcher
 import com.swmansion.gesturehandler.core.FlingGestureHandler
 import com.swmansion.gesturehandler.core.GestureHandler
@@ -47,9 +47,9 @@ import com.swmansion.gesturehandler.react.eventbuilders.TapGestureHandlerEventDa
 // 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)
+@ReactModule(name = RNGestureHandlerModule.NAME)
 class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
-  ReactContextBaseJavaModule(reactContext), GestureHandlerStateManager {
+  NativeRNGestureHandlerModuleSpec(reactContext), GestureHandlerStateManager {
   private abstract class HandlerFactory<T : GestureHandler<T>> {
     abstract val type: Class<T>
     abstract val name: String
@@ -71,6 +71,9 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       if (config.hasKey(KEY_MANUAL_ACTIVATION)) {
         handler.setManualActivation(config.getBoolean(KEY_MANUAL_ACTIVATION))
       }
+      if (config.hasKey("mouseButton")) {
+        handler.setMouseButton(config.getInt("mouseButton"))
+      }
     }
 
     abstract fun createEventBuilder(handler: T): GestureHandlerEventDataBuilder<T>
@@ -331,15 +334,21 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   private val interactionManager = RNGestureHandlerInteractionManager()
   private val roots: MutableList<RNGestureHandlerRootHelper> = ArrayList()
   private val reanimatedEventDispatcher = ReanimatedEventDispatcher()
-  override fun getName() = MODULE_NAME
+  override fun getName() = NAME
 
-  @ReactMethod
   @Suppress("UNCHECKED_CAST")
-  fun <T : GestureHandler<T>> createGestureHandler(
+  private fun <T : GestureHandler<T>> createGestureHandlerHelper(
     handlerName: String,
     handlerTag: Int,
     config: ReadableMap,
   ) {
+
+    if (registry.getHandler(handlerTag) !== null) {
+      throw IllegalStateException(
+        "Handler with tag $handlerTag already exists. Please ensure that no Gesture instance is used across multiple GestureDetectors."
+      )
+    }
+
     for (handlerFactory in handlerFactories as Array<HandlerFactory<T>>) {
       if (handlerFactory.name == handlerName) {
         val handler = handlerFactory.create(reactApplicationContext).apply {
@@ -356,7 +365,21 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   }
 
   @ReactMethod
-  fun attachGestureHandler(handlerTag: Int, viewTag: Int, actionType: Int) {
+  override fun createGestureHandler(
+    handlerName: String,
+    handlerTagDouble: Double,
+    config: ReadableMap,
+  ) {
+    val handlerTag = handlerTagDouble.toInt()
+
+    createGestureHandlerHelper(handlerName, handlerTag, config)
+  }
+
+  @ReactMethod
+  override fun attachGestureHandler(handlerTagDouble: Double, viewTagDouble: Double, actionTypeDouble: Double) {
+    val handlerTag = handlerTagDouble.toInt()
+    val viewTag = viewTagDouble.toInt()
+    val actionType = actionTypeDouble.toInt()
     // 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
@@ -366,9 +389,8 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
     }
   }
 
-  @ReactMethod
   @Suppress("UNCHECKED_CAST")
-  fun <T : GestureHandler<T>> updateGestureHandler(handlerTag: Int, config: ReadableMap) {
+  private fun <T : GestureHandler<T>> updateGestureHandlerHelper(handlerTag: Int, config: ReadableMap) {
     val handler = registry.getHandler(handlerTag) as T?
     if (handler != null) {
       val factory = findFactoryForHandler(handler)
@@ -381,19 +403,32 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   }
 
   @ReactMethod
-  fun dropGestureHandler(handlerTag: Int) {
+  override fun updateGestureHandler(handlerTagDouble: Double, config: ReadableMap) {
+    val handlerTag = handlerTagDouble.toInt()
+
+    updateGestureHandlerHelper(handlerTag, config)
+  }
+
+  @ReactMethod
+  override fun dropGestureHandler(handlerTagDouble: Double) {
+    val handlerTag = handlerTagDouble.toInt()
     interactionManager.dropRelationsForHandlerWithTag(handlerTag)
     registry.dropHandler(handlerTag)
   }
 
   @ReactMethod
-  fun handleSetJSResponder(viewTag: Int, blockNativeResponder: Boolean) {
+  override fun handleSetJSResponder(viewTagDouble: Double, blockNativeResponder: Boolean) {
+    val viewTag = viewTagDouble.toInt()
     val rootView = findRootHelperForViewAncestor(viewTag)
     rootView?.handleSetJSResponder(viewTag, blockNativeResponder)
   }
 
   @ReactMethod
-  fun handleClearJSResponder() {
+  override fun handleClearJSResponder() {
+  }
+
+  @ReactMethod
+  override fun flushOperations() {
   }
 
   override fun setGestureHandlerState(handlerTag: Int, newState: Int) {
@@ -409,16 +444,18 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   }
 
   @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
+  override fun install(): Boolean {
+    reactApplicationContext.runOnJSQueueThread {
+      try {
+        SoLoader.loadLibrary("gesturehandler")
+        val jsContext = reactApplicationContext.javaScriptContextHolder!!
+        decorateRuntime(jsContext.get())
+      } catch (exception: Exception) {
+        Log.w("[RNGestureHandler]", "Could not install JSI bindings.")
+      }
     }
+
+    return true
   }
 
   private external fun decorateRuntime(jsiPtr: Long)
@@ -442,7 +479,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
     )
   }
 
-  override fun onCatalystInstanceDestroy() {
+  override fun invalidate() {
     registry.dropAllHandlers()
     interactionManager.reset()
     synchronized(roots) {
@@ -455,7 +492,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
         }
       }
     }
-    super.onCatalystInstanceDestroy()
+    super.invalidate()
   }
 
   fun registerRootHelper(root: RNGestureHandlerRootHelper) {
@@ -611,7 +648,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   }
 
   companion object {
-    const val MODULE_NAME = "RNGestureHandlerModule"
+    const val 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"