react-native-gesture-handler 2.4.1 → 2.6.0

package/README.md

@@ -24,7 +24,7 @@ Check out our dedicated documentation page for info about this library, API refe
 If you want to play with the API but don't feel like trying it on a real app, you can run the example project. Clone the repo, go to the `example` folder and run:
 
 ```bash
-  yarn install
+yarn install
 ```
 
 If you are running on ios, run `pod install` in the ios folder
@@ -39,12 +39,14 @@ You will need to have an Android or iOS device or emulator connected as well as
 
 | version | react-native version |
 | ------- | -------------------- |
+| 2.0.0+  | 0.63.0+              |
 | 1.4.0+  | 0.60.0+              |
 | 1.1.0+  | 0.57.2+              |
 | <1.1.0  | 0.50.0+              |
 
 It may be possible to use newer versions of react-native-gesture-handler on React Native with version <= 0.59 by reverse Jetifying.
-Read more on that here https://github.com/mikehardy/jetifier#to-reverse-jetify--convert-node_modules-dependencies-to-support-libraries
+Read more on that here <https://github.com/mikehardy/jetifier#to-reverse-jetify--convert-node_modules-dependencies-to-support-libraries>
+
 ## License
 
 Gesture handler library is licensed under [The MIT License](LICENSE).

package/RNGestureHandler.podspec

@@ -1,6 +1,21 @@
 require "json"
 
-fabric_enabled = ENV['RCT_NEW_ARCH_ENABLED']
+fabric_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
+
+isUserApp = File.exists?(File.join(__dir__, "..", "..", "node_modules", "react-native", "package.json"))
+if isUserApp
+  libInstances = %x[find ../../ -name "package.json" | grep "/react-native-gesture-handler/package.json" | grep -v "/.yarn/"]
+  libInstancesArray = libInstances.split("\n")
+  if libInstancesArray.length() > 1
+    parsedLocation = ''
+    for location in libInstancesArray
+      location['../../'] = '- '
+      location['/package.json'] = ''
+      parsedLocation += location + "\n"
+    end
+    raise "[Gesture Handler] Multiple versions of Gesture Handler were detected. Only one instance of react-native-gesture-handler can be installed in a project. You need to resolve the conflict manually. Check out the documentation: https://docs.swmansion.com/react-native-gesture-handler/docs/troubleshooting#multiple-versions-of-reanimated-were-detected \n\nConflict between: \n" + parsedLocation
+  end
+end
 
 Pod::Spec.new do |s|
   # NPM package specification
@@ -17,9 +32,6 @@ Pod::Spec.new do |s|
   s.requires_arc = true
 
   if fabric_enabled
-    # folly_version must match the version used in React Native
-    # See folly_version in react-native/React/FBReactNativeSpec/FBReactNativeSpec.podspec
-    folly_version = '2021.06.28.00-v2'
     folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
 
     s.pod_target_xcconfig = {
@@ -32,7 +44,7 @@ Pod::Spec.new do |s|
     s.dependency "React"
     s.dependency "React-RCTFabric" # This is for fabric component
     s.dependency "React-Codegen"
-    s.dependency "RCT-Folly", folly_version
+    s.dependency "RCT-Folly"
     s.dependency "RCTRequired"
     s.dependency "RCTTypeSafety"
     s.dependency "ReactCommon/turbomodule/core"

package/android/build.gradle

@@ -21,7 +21,7 @@ def isNewArchitectureEnabled() {
     return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
 }
 
-def findNodeModulePath(baseDir, packageName) {
+static def findNodeModulePath(baseDir, packageName) {
     def basePath = baseDir.toPath().normalize()
     // Node's module resolution algorithm searches up to the root directory,
     // after which the base path will be null
@@ -35,6 +35,13 @@ def findNodeModulePath(baseDir, packageName) {
     return null
 }
 
+def findNodeModulePath(packageName) {
+    // Don't start in the project dir, as its path ends with node_modules/react-native-gesture-handler/android
+    // we want to go two levels up, so we end up in the first_node modules and eventually
+    // search upwards if the package is not found there
+    return findNodeModulePath(projectDir.toPath().parent.parent.toFile(), packageName)
+}
+
 if (isNewArchitectureEnabled()) {
     apply plugin: 'com.facebook.react'
 }
@@ -59,6 +66,45 @@ def shouldUseCommonInterfaceFromReanimated() {
     }
 }
 
+def reactNativeArchitectures() {
+    def value = project.getProperties().get("reactNativeArchitectures")
+    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def shouldAssertNoMultipleInstances() {
+  if (rootProject.hasProperty("disableMultipleInstancesCheck")) {
+    return rootProject.property("disableMultipleInstancesCheck") != "true"
+  } else {
+    return true
+  }
+}
+
+def noMultipleInstancesAssertion() {
+    Set<File> files = fileTree(rootDir.parent) {
+        include "node_modules/**/react-native-gesture-handler/package.json"
+        exclude "**/.yarn/**"
+    }.files
+
+    if (files.size() > 1) {
+        String parsedLocation = files.stream().map({ File file -> "- " + file.toString().replace("/package.json", "") }).collect().join("\n")
+        String exceptionMessage = "\n[Gesture Handler] Multiple instances of Gesture Handler were detected. Only one instance of react-native-gesture-handler can be installed in a project. You need to resolve the conflict manually. Check out the documentation: https://docs.swmansion.com/react-native-gesture-handler/docs/troubleshooting#multiple-instances-of-gesture-handler-were-detected \n\nConflict between: \n" + parsedLocation + "\n";
+        throw new Exception(exceptionMessage);
+    }
+}
+
+def REACT_NATIVE_DIR = findNodeModulePath("react-native")
+
+def assertionTask = task assertNoMultipleInstances {
+    onlyIf { shouldAssertNoMultipleInstances() }
+    doFirst {
+        noMultipleInstancesAssertion()
+    }
+}
+
+tasks.preBuild {
+    dependsOn assertionTask
+}
+
 repositories {
     mavenCentral()
 }
@@ -84,17 +130,12 @@ android {
         if (isNewArchitectureEnabled()) {
             var appProject = rootProject.allprojects.find {it.plugins.hasPlugin('com.android.application')}
             externalNativeBuild {
-                ndkBuild {
-                    arguments "APP_PLATFORM=android-21",
-                            "APP_STL=c++_shared",
-                            "NDK_TOOLCHAIN_VERSION=clang",
-                            "GENERATED_SRC_DIR=${appProject.buildDir}/generated/source",
-                            "PROJECT_BUILD_DIR=${appProject.buildDir}",
-                            "REACT_ANDROID_DIR=${findNodeModulePath(appProject.rootDir, "react-native") ?: "../node_modules/react-native/"}/ReactAndroid",
-                            "REACT_ANDROID_BUILD_DIR=${findNodeModulePath(appProject.rootDir, "react-native") ?: "../node_modules/react-native/"}/ReactAndroid/build"
-                    cFlags "-Wall", "-Werror", "-fexceptions", "-frtti", "-DWITH_INSPECTOR=1"
-                    cppFlags "-std=c++17"
-                    targets "rngesturehandler_modules"
+                cmake {
+                    cppFlags "-O2 -frtti -fexceptions -Wall -Wno-unused-variable -fstack-protector-all"
+                    arguments "-DAPP_BUILD_DIR=${appProject.buildDir}",
+                        "-DREACT_NATIVE_DIR=${REACT_NATIVE_DIR}",
+                        "-DANDROID_STL=c++_shared"
+                    abiFilters (*reactNativeArchitectures())
                 }
             }
         }
@@ -107,8 +148,8 @@ android {
 
     if (isNewArchitectureEnabled()) {
         externalNativeBuild {
-            ndkBuild {
-                path "src/main/jni/Android.mk"
+            cmake {
+                path "src/main/jni/CMakeLists.txt"
             }
         }
     }
@@ -116,7 +157,7 @@ android {
     packagingOptions {
         // For some reason gradle only complains about the duplicated version of libreact_render libraries
         // while there are more libraries copied in intermediates folder of the lib build directory, we exclude
-        // only the ones that make the build fail (ideally we should only include librngesturehandler_modules but we
+        // only the ones that make the build fail (ideally we should only include libgesturehandler but we
         // are only allowed to specify exclude patterns)
         exclude "**/libreact_render*.so"
     }
@@ -178,4 +219,19 @@ if (isNewArchitectureEnabled()) {
         libraryName = "rngesturehandler"
         codegenJavaPackageName = "com.swmansion.gesturehandler"
     }
+
+    // Resolves "LOCAL_SRC_FILES points to a missing file, Check that libfb.so exists or that its path is correct".
+    tasks.whenTaskAdded { task ->
+        if (task.name.contains("configureCMakeDebug")) {
+            rootProject.getTasksByName("packageReactNdkDebugLibs", true).forEach {
+                task.dependsOn(it)
+            }
+        }
+        // We want to add a dependency for both configureCMakeRelease and configureCMakeRelWithDebInfo
+        if (task.name.contains("configureCMakeRel")) {
+            rootProject.getTasksByName("packageReactNdkReleaseLibs", true).forEach {
+                task.dependsOn(it)
+            }
+        }
+    }
 }

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

@@ -1,6 +1,7 @@
 package com.swmansion.gesturehandler
 
 import android.os.Handler
+import android.os.Looper
 import android.view.MotionEvent
 
 class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
@@ -27,7 +28,7 @@ class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
     begin()
     maxNumberOfPointersSimultaneously = 1
     if (handler == null) {
-      handler = Handler() // lazy delegate?
+      handler = Handler(Looper.getMainLooper()) // lazy delegate?
     } else {
       handler!!.removeCallbacksAndMessages(null)
     }

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

@@ -172,8 +172,12 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
       windowOffset[0] = 0
       windowOffset[1] = 0
     }
+
+    onPrepare()
   }
 
+  protected open fun onPrepare() {}
+
   private fun getWindow(context: Context?): Window? {
     if (context == null) return null
     if (context is Activity) return context.window
@@ -253,9 +257,9 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
     initPointerProps(trackedPointersIDsCount)
     var count = 0
-    val oldX = event.x
-    val oldY = event.y
-    event.setLocation(event.rawX, event.rawY)
+    val deltaX = event.rawX - event.x
+    val deltaY = event.rawY - event.y
+    event.offsetLocation(deltaX, deltaY)
     var index = 0
     val size = event.pointerCount
     while (index < size) {
@@ -298,8 +302,8 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     } catch (e: IllegalArgumentException) {
       throw AdaptEventException(this, event, e)
     }
-    event.setLocation(oldX, oldY)
-    result.setLocation(oldX, oldY)
+    event.offsetLocation(-deltaX, -deltaY)
+    result.offsetLocation(-deltaX, -deltaY)
     return result
   }
 

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

@@ -5,6 +5,7 @@ import android.graphics.PointF
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
+import android.widget.EditText
 import java.util.*
 
 class GestureHandlerOrchestrator(
@@ -128,6 +129,13 @@ class GestureHandlerOrchestrator(
           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
@@ -142,9 +150,12 @@ class GestureHandlerOrchestrator(
     } else if (prevState == GestureHandler.STATE_ACTIVE || prevState == GestureHandler.STATE_END) {
       if (handler.isActive) {
         handler.dispatchStateChange(newState, prevState)
-      } else if (prevState == GestureHandler.STATE_ACTIVE) {
-        // handle edge case where handler awaiting for another one tries to activate but finishes
-        // before the other would not send state change event upon ending
+      } else if (prevState == GestureHandler.STATE_ACTIVE && (newState == GestureHandler.STATE_CANCELLED || newState == GestureHandler.STATE_FAILED)) {
+        // Handle edge case where handler awaiting for another one tries to activate but finishes
+        // before the other would not send state change event upon ending. Note that we only want
+        // to do this if the newState is either CANCELLED or FAILED, if it is END we still want to
+        // wait for the other handler to finish as in that case synthetic events will be sent by the
+        // makeActive method.
         handler.dispatchStateChange(newState, GestureHandler.STATE_BEGAN)
       }
     } else if (prevState != GestureHandler.STATE_UNDETERMINED || newState != GestureHandler.STATE_CANCELLED) {
@@ -474,9 +485,24 @@ class GestureHandlerOrchestrator(
       }
       PointerEventsConfig.BOX_NONE -> {
         // This view can't be the target, but its children might
-        if (view is ViewGroup) {
-          extractGestureHandlers(view, coords, pointerId)
-        } else false
+        when (view) {
+          is ViewGroup -> {
+            extractGestureHandlers(view, coords, pointerId).also { found ->
+              // A child view is handling touch, also extract handlers attached to this view
+              if (found) {
+                recordViewHandlersForPointer(view, coords, pointerId)
+              }
+            }
+          }
+          // When <TextInput> has editable set to `false` getPointerEventsConfigForView returns
+          // `BOX_NONE` as it's `isEnabled` property is false. In this case we still want to extract
+          // handlers attached to the text input, as it makes sense that gestures would work on a
+          // non-editable TextInput.
+          is EditText -> {
+            recordViewHandlersForPointer(view, coords, pointerId)
+          }
+          else -> false
+        }
       }
       PointerEventsConfig.AUTO -> {
         // Either this view or one of its children is the target

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

@@ -2,6 +2,7 @@ package com.swmansion.gesturehandler
 
 import android.content.Context
 import android.os.Handler
+import android.os.Looper
 import android.os.SystemClock
 import android.view.MotionEvent
 
@@ -19,7 +20,9 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
 
   init {
     setShouldCancelWhenOutside(true)
-    defaultMaxDistSq = DEFAULT_MAX_DIST_DP * context.resources.displayMetrics.density
+
+    val defaultMaxDist = DEFAULT_MAX_DIST_DP * context.resources.displayMetrics.density
+    defaultMaxDistSq = defaultMaxDist * defaultMaxDist
     maxDistSq = defaultMaxDistSq
   }
 
@@ -41,7 +44,7 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
       begin()
       startX = event.rawX
       startY = event.rawY
-      handler = Handler()
+      handler = Handler(Looper.getMainLooper())
       if (minDurationMs > 0) {
         handler!!.postDelayed({ activate() }, minDurationMs)
       } else if (minDurationMs == 0L) {

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

@@ -3,12 +3,16 @@ package com.swmansion.gesturehandler
 import android.os.SystemClock
 import android.view.MotionEvent
 import android.view.View
+import android.view.ViewConfiguration
 import android.view.ViewGroup
-import com.swmansion.gesturehandler.react.RNGestureHandlerButtonViewManager
+import com.facebook.react.views.textinput.ReactEditText
 
 class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
   private var shouldActivateOnStart = false
-  private var disallowInterruption = false
+  var disallowInterruption = false
+    private set
+
+  private var hook: NativeViewGestureHandlerHook = defaultHook
 
   init {
     setShouldCancelWhenOutside(true)
@@ -34,13 +38,17 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
   }
 
   override fun shouldRecognizeSimultaneously(handler: GestureHandler<*>): Boolean {
+    // if the gesture is marked by user as simultaneous with other or the hook return true
+    if (super.shouldRecognizeSimultaneously(handler) || hook.shouldRecognizeSimultaneously(handler)) {
+      return true
+    }
+
     if (handler is NativeViewGestureHandler) {
       // Special case when the peer handler is also an instance of NativeViewGestureHandler:
       // For the `disallowInterruption` to work correctly we need to check the property when
       // accessed as a peer, because simultaneous recognizers can be set on either side of the
       // connection.
-      val nativeWrapper = handler
-      if (nativeWrapper.state == STATE_ACTIVE && nativeWrapper.disallowInterruption) {
+      if (handler.state == STATE_ACTIVE && handler.disallowInterruption) {
         // other handler is active and it disallows interruption, we don't want to get into its way
         return false
       }
@@ -52,7 +60,7 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
       // as it means the other handler has turned active and returning `true` would prevent it from
       // interrupting the current handler
       false
-    } else state == STATE_ACTIVE && canBeInterrupted
+    } else state == STATE_ACTIVE && canBeInterrupted && (!hook.shouldCancelRootViewGestureHandlerIfNecessary() || handler.tag > 0)
     // otherwise we can only return `true` if already in an active state
   }
 
@@ -60,19 +68,10 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
     return !disallowInterruption
   }
 
-  private fun canStart(): Boolean {
-    val view = view
-    if (view is StateChangeHook) {
-      return view.canStart()
-    }
-
-    return true
-  }
-
-  private fun afterGestureEnd() {
-    val view = view
-    if (view is StateChangeHook) {
-      view.afterGestureEnd()
+  override fun onPrepare() {
+    when (val view = view) {
+      is NativeViewGestureHandlerHook -> this.hook = view
+      is ReactEditText -> this.hook = EditTextHook(this, view)
     }
   }
 
@@ -84,7 +83,7 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
         activate()
       }
       end()
-      afterGestureEnd()
+      hook.afterGestureEnd(event)
     } else if (state == STATE_UNDETERMINED || state == STATE_BEGAN) {
       when {
         shouldActivateOnStart -> {
@@ -96,8 +95,11 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
           view.onTouchEvent(event)
           activate()
         }
+        hook.wantsToHandleEventBeforeActivation() -> {
+          hook.handleEventBeforeActivation(event)
+        }
         state != STATE_BEGAN -> {
-          if (canStart()) {
+          if (hook.canBegin()) {
             begin()
           } else {
             cancel()
@@ -117,13 +119,93 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
     view!!.onTouchEvent(event)
   }
 
+  override fun onReset() {
+    this.hook = defaultHook
+  }
+
   companion object {
     private fun tryIntercept(view: View, event: MotionEvent) =
       view is ViewGroup && view.onInterceptTouchEvent(event)
+
+    private val defaultHook = object : NativeViewGestureHandlerHook {}
   }
 
-  interface StateChangeHook {
-    fun canStart(): Boolean
-    fun afterGestureEnd()
+  interface NativeViewGestureHandlerHook {
+    /**
+     * Called when gesture is in the UNDETERMINED state, shouldActivateOnStart is set to false,
+     * and both tryIntercept and wantsToHandleEventBeforeActivation returned false.
+     *
+     * @return Boolean value signalling whether the handler can transition to the BEGAN state. If false
+     * the gesture will be cancelled.
+     */
+    fun canBegin() = true
+
+    /**
+     * Called after the gesture transitions to the END state.
+     */
+    fun afterGestureEnd(event: MotionEvent) = Unit
+
+    /**
+     * @return Boolean value signalling whether the gesture can be recognized simultaneously with
+     * other (handler). Returning false doesn't necessarily prevent it from happening.
+     */
+    fun shouldRecognizeSimultaneously(handler: GestureHandler<*>) = false
+
+    /**
+     * shouldActivateOnStart and tryIntercept have priority over this method
+     *
+     * @return Boolean value signalling if the hook wants to handle events passed to the handler
+     * before it activates (after that the events are passed to the underlying view).
+     */
+    fun wantsToHandleEventBeforeActivation() = false
+
+    /**
+     * Will be called with events if wantsToHandleEventBeforeActivation returns true.
+     */
+    fun handleEventBeforeActivation(event: MotionEvent) = Unit
+
+    /**
+     * @return Boolean value indicating whether the RootViewGestureHandler should be cancelled
+     * by this one.
+     */
+    fun shouldCancelRootViewGestureHandlerIfNecessary() = false
+  }
+
+  private class EditTextHook(
+          private val handler: NativeViewGestureHandler,
+          private val editText: ReactEditText
+  ) : NativeViewGestureHandlerHook {
+    private var startX = 0f
+    private var startY = 0f
+    private var touchSlopSquared: Int
+
+    init {
+      val vc = ViewConfiguration.get(editText.context)
+      touchSlopSquared = vc.scaledTouchSlop * vc.scaledTouchSlop
+    }
+
+    override fun afterGestureEnd(event: MotionEvent) {
+      if ((event.x - startX) * (event.x - startX) + (event.y - startY) * (event.y - startY) < touchSlopSquared) {
+        editText.requestFocusFromJS()
+      }
+    }
+
+    // recognize alongside every handler besides RootViewGestureHandler, which is a private inner class
+    // of RNGestureHandlerRootHelper so no explicit type checks, but its tag is always negative
+    // also if other handler is NativeViewGestureHandler then don't override the default implementation
+    override fun shouldRecognizeSimultaneously(handler: GestureHandler<*>) =
+            handler.tag > 0 && handler !is NativeViewGestureHandler
+
+    override fun wantsToHandleEventBeforeActivation() = true
+
+    override fun handleEventBeforeActivation(event: MotionEvent) {
+      handler.activate()
+      editText.onTouchEvent(event)
+
+      startX = event.x
+      startY = event.y
+    }
+
+    override fun shouldCancelRootViewGestureHandlerIfNecessary() = true
   }
 }

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

@@ -1,6 +1,8 @@
 package com.swmansion.gesturehandler
 
 import android.content.Context
+import android.os.Handler
+import android.os.Looper
 import android.view.MotionEvent
 import android.view.VelocityTracker
 import android.view.ViewConfiguration
@@ -40,6 +42,9 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
   private var lastY = 0f
   private var velocityTracker: VelocityTracker? = null
   private var averageTouches = false
+  private var activateAfterLongPress = DEFAULT_ACTIVATE_AFTER_LONG_PRESS
+  private val activateDelayed = Runnable { activate() }
+  private var handler: Handler? = null
 
   /**
    * On Android when there are multiple pointers on the screen pan gestures most often just consider
@@ -54,7 +59,7 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
    * position of all the fingers will remain still while doing a rotation gesture.
    */
   init {
-    val vc = ViewConfiguration.get(context)
+    val vc = ViewConfiguration.get(context!!)
     val touchSlop = vc.scaledTouchSlop
     defaultMinDistSq = (touchSlop * touchSlop).toFloat()
     minDistSq = defaultMinDistSq
@@ -76,6 +81,7 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
     minDistSq = defaultMinDistSq
     minPointers = DEFAULT_MIN_POINTERS
     maxPointers = DEFAULT_MAX_POINTERS
+    activateAfterLongPress = DEFAULT_ACTIVATE_AFTER_LONG_PRESS
     averageTouches = false
   }
 
@@ -127,6 +133,10 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
     this.averageTouches = averageTouches
   }
 
+  fun setActivateAfterLongPress(time: Long) = apply {
+    this.activateAfterLongPress = time
+  }
+
   /**
    * @param minVelocity in pixels per second
    */
@@ -177,13 +187,18 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
 
   private fun shouldFail(): Boolean {
     val dx = lastX - startX + offsetX
+    val dy = lastY - startY + offsetY
+
+    if (activateAfterLongPress > 0 && dx * dx + dy * dy > defaultMinDistSq) {
+      handler?.removeCallbacksAndMessages(null)
+      return true
+    }
     if (failOffsetXStart != MAX_VALUE_IGNORE && dx < failOffsetXStart) {
       return true
     }
     if (failOffsetXEnd != MIN_VALUE_IGNORE && dx > failOffsetXEnd) {
       return true
     }
-    val dy = lastY - startY + offsetY
     if (failOffsetYStart != MAX_VALUE_IGNORE && dy < failOffsetYStart) {
       return true
     }
@@ -216,6 +231,13 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       velocityTracker = VelocityTracker.obtain()
       addVelocityMovement(velocityTracker, event)
       begin()
+
+      if (activateAfterLongPress > 0) {
+        if (handler == null) {
+          handler = Handler(Looper.getMainLooper())
+        }
+        handler!!.postDelayed(activateDelayed, activateAfterLongPress)
+      }
     } else if (velocityTracker != null) {
       addVelocityMovement(velocityTracker, event)
       velocityTracker!!.computeCurrentVelocity(1000)
@@ -257,7 +279,12 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
     super.activate(force)
   }
 
+  override fun onCancel() {
+    handler?.removeCallbacksAndMessages(null)
+  }
+
   override fun onReset() {
+    handler?.removeCallbacksAndMessages(null)
     velocityTracker?.let {
       it.recycle()
       velocityTracker = null
@@ -274,6 +301,7 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
     private const val MAX_VALUE_IGNORE = Float.MIN_VALUE
     private const val DEFAULT_MIN_POINTERS = 1
     private const val DEFAULT_MAX_POINTERS = 10
+    private const val DEFAULT_ACTIVATE_AFTER_LONG_PRESS = 0L
 
     /**
      * This method adds movement to {@class VelocityTracker} first resetting offset of the event so

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

@@ -1,6 +1,7 @@
 package com.swmansion.gesturehandler
 
 import android.os.Handler
+import android.os.Looper
 import android.view.MotionEvent
 import com.swmansion.gesturehandler.GestureUtils.getLastPointerX
 import com.swmansion.gesturehandler.GestureUtils.getLastPointerY
@@ -70,7 +71,7 @@ class TapGestureHandler : GestureHandler<TapGestureHandler>() {
 
   private fun startTap() {
     if (handler == null) {
-      handler = Handler() // TODO: lazy init (handle else branch correctly)
+      handler = Handler(Looper.getMainLooper()) // TODO: lazy init (handle else branch correctly)
     } else {
       handler!!.removeCallbacksAndMessages(null)
     }
@@ -79,7 +80,7 @@ class TapGestureHandler : GestureHandler<TapGestureHandler>() {
 
   private fun endTap() {
     if (handler == null) {
-      handler = Handler()
+      handler = Handler(Looper.getMainLooper())
     } else {
       handler!!.removeCallbacksAndMessages(null)
     }

package/android/src/fabric/java/com/swmansion/gesturehandler/RNGestureHandlerComponentsRegistry.java

@@ -9,7 +9,7 @@ import com.facebook.soloader.SoLoader;
 public class RNGestureHandlerComponentsRegistry {
   static {
     SoLoader.loadLibrary("fabricjni");
-    SoLoader.loadLibrary("rngesturehandler_modules");
+    SoLoader.loadLibrary("gesturehandler");
   }
 
   @DoNotStrip private final HybridData mHybridData;