react-native-gesture-handler 3.0.0-beta.3 → 3.0.0-beta.5

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

@@ -16,61 +16,33 @@ import com.swmansion.gesturehandler.react.RNGestureHandlerRootView
 class RNGestureHandlerDetectorView(context: Context) : ReactViewGroup(context) {
   private val reactContext: ThemedReactContext
     get() = context as ThemedReactContext
-  private var handlersToAttach: List<Int>? = null
-  private var virtualChildrenToAttach: List<VirtualChildren>? = null
+  private var handlersToAttach: List<Int> = emptyList()
+  private var virtualChildrenToAttach: List<VirtualChildren> = emptyList()
   private var nativeHandlers: MutableSet<Int> = mutableSetOf()
+  private var subscribedHandlers: MutableSet<Int> = mutableSetOf()
   private var attachedHandlers: MutableSet<Int> = mutableSetOf()
-  private var attachedVirtualHandlers: MutableMap<Int, MutableSet<Int>> = mutableMapOf()
+  private var subscribedVirtualHandlers: MutableMap<Int, MutableSet<Int>> = mutableMapOf()
   private var moduleId: Int = -1
 
   data class VirtualChildren(val handlerTags: List<Int>, val viewTag: Int)
 
   fun setHandlerTags(handlerTags: ReadableArray?) {
-    val newHandlers = handlerTags?.toArrayList()?.map { (it as Double).toInt() } ?: emptyList()
-    if (moduleId == -1) {
-      // It's possible that handlerTags will be set before module id. In that case, store
-      // the handler ids and attach them after setting module id.
-      handlersToAttach = newHandlers
-      return
+    handlersToAttach = handlerTags?.toArrayList()?.map { (it as Double).toInt() } ?: emptyList()
+    if (moduleId != -1) {
+      attachHandlers(handlersToAttach)
     }
-
-    attachHandlers(newHandlers)
   }
 
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
-
     if (moduleId != -1) {
-      handlersToAttach?.let {
-        attachHandlers(it)
-      }
-
-      virtualChildrenToAttach?.let {
-        attachVirtualChildren(it)
-      }
-
-      handlersToAttach = null
-      virtualChildrenToAttach = null
+      attachHandlers(handlersToAttach)
+      attachVirtualChildren(virtualChildrenToAttach)
     }
   }
 
   override fun onDetachedFromWindow() {
-    if (attachedHandlers.isNotEmpty()) {
-      handlersToAttach = attachedHandlers.toMutableList().also {
-        it.addAll(handlersToAttach ?: emptyList())
-      }
-    }
-
-    if (attachedVirtualHandlers.isNotEmpty()) {
-      virtualChildrenToAttach = attachedVirtualHandlers.map {
-        VirtualChildren(it.value.toList(), it.key)
-      }.toMutableList().also {
-        it.addAll(virtualChildrenToAttach ?: emptyList())
-      }
-    }
-
     detachAllHandlers()
-
     super.onDetachedFromWindow()
   }
 
@@ -78,30 +50,15 @@ class RNGestureHandlerDetectorView(context: Context) : ReactViewGroup(context) {
     assert(this.moduleId == -1) { "Tried to change moduleId of a native detector" }
 
     this.moduleId = id
-    this.attachHandlers(handlersToAttach ?: return)
-    handlersToAttach = null
-    this.attachVirtualChildren(virtualChildrenToAttach ?: return)
-    virtualChildrenToAttach = null
+    attachHandlers(handlersToAttach)
+    attachVirtualChildren(virtualChildrenToAttach)
   }
 
   fun setVirtualChildren(newVirtualChildren: ReadableArray?) {
-    val mappedChildren = newVirtualChildren?.mapVirtualChildren().orEmpty()
-
-    if (moduleId == -1) {
-      // It's possible that handlerTags will be set before module id. In that case, store
-      // the handler ids and attach them after setting module id.
-      virtualChildrenToAttach = mappedChildren
-      return
+    virtualChildrenToAttach = newVirtualChildren?.mapVirtualChildren().orEmpty()
+    if (moduleId != -1) {
+      attachVirtualChildren(virtualChildrenToAttach)
     }
-
-    attachVirtualChildren(mappedChildren)
-  }
-
-  private fun shouldAttachGestureToChildView(tag: Int): Boolean {
-    val registry = RNGestureHandlerModule.registries[moduleId]
-      ?: throw Exception("Tried to access a non-existent registry")
-
-    return registry.getHandler(tag)?.wantsToAttachDirectlyToView() ?: false
   }
 
   // We override this `addView` because it is called inside `addView(child: View?, index: Int)`
@@ -127,49 +84,61 @@ class RNGestureHandlerDetectorView(context: Context) : ReactViewGroup(context) {
     newHandlers: List<Int>,
     viewTag: Int = this.id,
     actionType: Int = GestureHandler.ACTION_TYPE_NATIVE_DETECTOR,
-    attachedHandlers: MutableSet<Int> = this.attachedHandlers,
+    subscribedHandlers: MutableSet<Int> = this.subscribedHandlers,
   ) {
     val registry = RNGestureHandlerModule.registries[moduleId]
       ?: throw Exception("Tried to access a non-existent registry")
 
-    val handlersToDetach = attachedHandlers.toMutableSet()
+    val handlersToDetach = subscribedHandlers.toMutableSet()
 
     for (tag in newHandlers) {
       handlersToDetach.remove(tag)
-      if (!attachedHandlers.contains(tag)) {
-        if (shouldAttachGestureToChildView(tag) && actionType == GestureHandler.ACTION_TYPE_NATIVE_DETECTOR) {
-          // It might happen that `attachHandlers` will be called before children are added into view hierarchy. In that case we cannot
-          // attach `NativeViewGestureHandlers` here and we have to do it in `addView` method.
-          assert(childCount <= 1) {
-            "Cannot attach native gesture handlers when the detector has multiple children"
-          }
-          nativeHandlers.add(tag)
-        } else {
-          registry.attachHandlerToView(tag, viewTag, actionType, this)
-          if (actionType == GestureHandler.ACTION_TYPE_VIRTUAL_DETECTOR) {
-            registry.getHandler(tag)?.hostDetectorView = this
-          }
-          attachedHandlers.add(tag)
+      if (!subscribedHandlers.contains(tag)) {
+        registry.observeHandler(tag, this) { handler ->
+          attachReadyHandler(handler, actionType, viewTag)
         }
+        subscribedHandlers.add(tag)
       }
     }
 
     for (tag in handlersToDetach) {
-      registry.detachHandlerFromHostDetector(tag, this)
+      registry.cancelObservation(tag, this)
+      if (attachedHandlers.contains(tag)) {
+        registry.detachHandlerFromHostDetector(tag, this)
+        attachedHandlers.remove(tag)
+      }
+      subscribedHandlers.remove(tag)
       nativeHandlers.remove(tag)
-      attachedHandlers.remove(tag)
     }
+  }
 
-    val child = getChildAt(0)
+  // Invoked from the registry's `observeHandler` callback once the handler is known to exist.
+  // Branches on handler kind + actionType to pick the right binding flow. May be called multiple
+  // times for the same tag (handler re-registration), so each branch must be idempotent.
+  private fun attachReadyHandler(handler: GestureHandler, actionType: Int, viewTag: Int) {
+    val registry = RNGestureHandlerModule.registries[moduleId]
+      ?: throw Exception("Tried to access a non-existent registry")
 
-    // This covers the case where `NativeViewGestureHandlers` are attached after child views were created.
-    if (child != null) {
-      tryAttachNativeHandlersToChildView(child)
+    if (handler.wantsToAttachDirectlyToView() && actionType == GestureHandler.ACTION_TYPE_NATIVE_DETECTOR) {
+      assert(childCount <= 1) {
+        "Cannot attach native gesture handlers when the detector has multiple children"
+      }
+      nativeHandlers.add(handler.tag)
+      if (childCount != 0) {
+        tryAttachNativeHandlersToChildView(getChildAt(0))
+      }
+      return
     }
+
+    registry.attachHandlerToView(handler.tag, viewTag, actionType, this)
+    if (actionType == GestureHandler.ACTION_TYPE_VIRTUAL_DETECTOR) {
+      handler.hostDetectorView = this
+    }
+    attachedHandlers.add(handler.tag)
   }
 
   private fun attachVirtualChildren(virtualChildrenToAttach: List<VirtualChildren>) {
-    val virtualChildrenToDetach = attachedVirtualHandlers.keys.toMutableSet()
+    val virtualChildrenToDetach = subscribedVirtualHandlers.keys.toMutableSet()
 
     for (child in virtualChildrenToAttach) {
       virtualChildrenToDetach.remove(child.viewTag)
@@ -179,22 +148,26 @@ class RNGestureHandlerDetectorView(context: Context) : ReactViewGroup(context) {
       ?: throw Exception("Tried to access a non-existent registry")
 
     for (child in virtualChildrenToDetach) {
-      for (tag in attachedVirtualHandlers[child]!!) {
-        registry.detachHandlerFromHostDetector(tag, this)
+      for (tag in subscribedVirtualHandlers[child]!!) {
+        registry.cancelObservation(tag, this)
+        if (attachedHandlers.contains(tag)) {
+          registry.detachHandlerFromHostDetector(tag, this)
+          attachedHandlers.remove(tag)
+        }
       }
-      attachedVirtualHandlers.remove(tag)
+      subscribedVirtualHandlers.remove(child)
     }
 
     for (child in virtualChildrenToAttach) {
-      if (!attachedVirtualHandlers.containsKey(child.viewTag)) {
-        attachedVirtualHandlers[child.viewTag] = mutableSetOf()
+      if (!subscribedVirtualHandlers.containsKey(child.viewTag)) {
+        subscribedVirtualHandlers[child.viewTag] = mutableSetOf()
       }
 
       attachHandlers(
         child.handlerTags,
         child.viewTag,
         GestureHandler.ACTION_TYPE_VIRTUAL_DETECTOR,
-        attachedVirtualHandlers[child.viewTag]!!,
+        subscribedVirtualHandlers[child.viewTag]!!,
       )
     }
   }
@@ -225,8 +198,13 @@ class RNGestureHandlerDetectorView(context: Context) : ReactViewGroup(context) {
     }
 
     for (tag in nativeHandlers) {
+      // Defensive: a tag may be in `nativeHandlers` from an earlier ready callback but the
+      // underlying handler may have been dropped since. Skip; a re-registration will fire the
+      // observation again.
+      if (registry.getHandler(tag) == null) {
+        continue
+      }
       registry.attachHandlerToView(tag, id, GestureHandler.ACTION_TYPE_NATIVE_DETECTOR, this)
-
       attachedHandlers.add(tag)
     }
   }
@@ -236,6 +214,9 @@ class RNGestureHandlerDetectorView(context: Context) : ReactViewGroup(context) {
       ?: throw Exception("Tried to access a non-existent registry")
 
     for (tag in nativeHandlers) {
+      if (!attachedHandlers.contains(tag)) {
+        continue
+      }
       registry.detachHandlerFromHostDetector(tag, this)
       attachedHandlers.remove(tag)
     }
@@ -247,20 +228,16 @@ class RNGestureHandlerDetectorView(context: Context) : ReactViewGroup(context) {
   }
 
   fun detachAllHandlers() {
-    val registry = RNGestureHandlerModule.registries[moduleId]
-      ?: throw Exception("Tried to access a non-existent registry")
-
-    for (tag in attachedHandlers.toMutableSet()) {
-      registry.detachHandlerFromHostDetector(tag, this)
-      attachedHandlers.remove(tag)
-    }
-
-    for (child in attachedVirtualHandlers) {
-      for (tag in child.value) {
+    RNGestureHandlerModule.registries[moduleId]?.let { registry ->
+      registry.cancelAllObservationsForOwner(this)
+      for (tag in attachedHandlers) {
         registry.detachHandlerFromHostDetector(tag, this)
       }
-      child.value.clear()
     }
+    attachedHandlers.clear()
+    subscribedVirtualHandlers.clear()
+    subscribedHandlers.clear()
+    nativeHandlers.clear()
   }
 
   fun recordHandlerIfNotPresent(handler: GestureHandler) {

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

@@ -50,7 +50,7 @@ class RNGestureHandlerInteractionManager : GestureHandlerInteractionController {
 
   override fun shouldHandlerBeCancelledBy(handler: GestureHandler, otherHandler: GestureHandler): Boolean {
     if (otherHandler is NativeViewGestureHandler) {
-      return otherHandler.disallowInterruption
+      return !otherHandler.canBeInterruptedBy(handler)
     }
 
     if (otherHandler is RNGestureHandlerRootHelper.RootViewGestureHandler) {

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

@@ -28,7 +28,6 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   @DoNotStrip
   @Suppress("unused")
   private var mHybridData: HybridData = initHybrid()
-  private var isReanimatedAvailable = false
   private var uiRuntimeDecorated = false
   private val registry: RNGestureHandlerRegistry
     get() = registries[moduleId]!!
@@ -61,16 +60,10 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   }
 
   @ReactMethod
-  override fun createGestureHandler(handlerName: String, handlerTagDouble: Double, config: ReadableMap): Boolean {
-    if (isReanimatedAvailable && !uiRuntimeDecorated) {
-      uiRuntimeDecorated = decorateUIRuntime()
-    }
-
+  override fun createGestureHandler(handlerName: String, handlerTagDouble: Double, config: ReadableMap) {
     val handlerTag = handlerTagDouble.toInt()
 
     createGestureHandlerHelper<GestureHandler>(handlerName, handlerTag, config)
-
-    return true
   }
 
   @ReactMethod
@@ -125,8 +118,12 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
   override fun flushOperations() = Unit
 
   @ReactMethod
-  override fun setReanimatedAvailable(isAvailable: Boolean) {
-    isReanimatedAvailable = isAvailable
+  override fun installUIRuntimeBindings(): Boolean {
+    if (!uiRuntimeDecorated) {
+      uiRuntimeDecorated = decorateUIRuntime()
+    }
+
+    return uiRuntimeDecorated
   }
 
   @DoNotStrip

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

@@ -11,10 +11,72 @@ class RNGestureHandlerRegistry : GestureHandlerRegistry {
   private val handlers = SparseArray<GestureHandler>()
   private val attachedTo = SparseArray<Int?>()
   private val handlersForView = SparseArray<ArrayList<GestureHandler>>()
+  private val observers = mutableMapOf<Int, MutableMap<Any, (GestureHandler) -> Unit>>()
 
-  @Synchronized
   fun registerHandler(handler: GestureHandler) {
-    handlers.put(handler.tag, handler)
+    val hasObservers = synchronized(this) {
+      handlers.put(handler.tag, handler)
+      observers[handler.tag]?.isNotEmpty() == true
+    }
+
+    if (!hasObservers) {
+      return
+    }
+
+    // `createGestureHandler` runs on the JS thread, but observer callbacks read detector
+    // view state (childCount, getChildAt) and may attach native handlers, so they must run
+    // on the UI thread. Re-resolve the observer list on the UI thread so a cancellation that
+    // happens between this post and `notify` running (e.g. detector detach) actually prevents
+    // the callback.
+    val notify = {
+      val callbacks = synchronized(this) {
+        observers[handler.tag]?.values?.toList().orEmpty()
+      }
+      for (callback in callbacks) {
+        callback(handler)
+      }
+    }
+
+    if (UiThreadUtil.isOnUiThread()) {
+      notify()
+    } else {
+      UiThreadUtil.runOnUiThread(notify)
+    }
+  }
+
+  // Invokes `block` every time a handler with `tag` is registered, and synchronously once now if
+  // the handler already exists. The observation persists until explicitly cancelled: the registry
+  // holds both `owner` and `block` strongly, so callers MUST call `cancelObservation` or
+  // `cancelAllObservationsForOwner` when the owner is going away (typically in detach / dispose
+  // paths) to avoid leaking the owner. Observing the same tag twice with the same `owner` replaces
+  // the previous block.
+  fun observeHandler(tag: Int, owner: Any, block: (GestureHandler) -> Unit) {
+    val existing = synchronized(this) {
+      observers.getOrPut(tag) { mutableMapOf() }[owner] = block
+      handlers[tag]
+    }
+    existing?.let { block(it) }
+  }
+
+  @Synchronized
+  fun cancelObservation(tag: Int, owner: Any) {
+    val observersForTag = observers[tag] ?: return
+    observersForTag.remove(owner)
+    if (observersForTag.isEmpty()) {
+      observers.remove(tag)
+    }
+  }
+
+  @Synchronized
+  fun cancelAllObservationsForOwner(owner: Any) {
+    val iterator = observers.entries.iterator()
+    while (iterator.hasNext()) {
+      val entry = iterator.next()
+      entry.value.remove(owner)
+      if (entry.value.isEmpty()) {
+        iterator.remove()
+      }
+    }
   }
 
   @Synchronized

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

@@ -13,6 +13,7 @@ import com.facebook.react.uimanager.RootView
 import com.facebook.react.uimanager.ThemedReactContext
 import com.swmansion.gesturehandler.core.GestureHandler
 import com.swmansion.gesturehandler.core.GestureHandlerOrchestrator
+import com.swmansion.gesturehandler.core.OnJSResponderCancelListener
 
 class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView: ViewGroup, private val moduleId: Int) {
   private val orchestrator: GestureHandlerOrchestrator?
@@ -34,11 +35,26 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:
       ReactConstants.TAG,
       "[GESTURE HANDLER] Initialize gesture handler for root view $rootView",
     )
+    val onJSResponderCancelListener = object : OnJSResponderCancelListener {
+      override fun onCancelJSResponderRequested(handler: GestureHandler) {
+        val time = SystemClock.uptimeMillis()
+        val event = MotionEvent.obtain(time, time, MotionEvent.ACTION_CANCEL, 0f, 0f, 0)
+        if (rootView is RootView) {
+          rootView.onChildStartedNativeGesture(rootView, event)
+        }
+        event.recycle()
+      }
+
+      override fun onCancelJSResponderReleased(handler: GestureHandler) {
+        shouldIntercept = false
+      }
+    }
     orchestrator = GestureHandlerOrchestrator(
       wrappedView,
       registry,
       RNViewConfigurationHelper(),
       rootView,
+      onJSResponderCancelListener,
     ).apply {
       minimumAlphaForTraversal = MIN_ALPHA_FOR_TOUCH
     }
@@ -66,6 +82,8 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:
   }
 
   internal inner class RootViewGestureHandler(handlerTag: Int) : GestureHandler() {
+    override val isContinuous = true
+
     init {
       this.tag = handlerTag
     }
@@ -95,14 +113,6 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:
 
     override fun onCancel() {
       shouldIntercept = true
-      val time = SystemClock.uptimeMillis()
-      val event = MotionEvent.obtain(time, time, MotionEvent.ACTION_CANCEL, 0f, 0f, 0).apply {
-        action = MotionEvent.ACTION_CANCEL
-      }
-      if (rootView is RootView) {
-        rootView.onChildStartedNativeGesture(rootView, event)
-      }
-      event.recycle()
     }
   }
 

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

@@ -45,10 +45,21 @@ class RNGestureHandlerRootView(context: Context?) : ReactViewGroup(context) {
     rootHelper?.recordHandlerIfNotPresent(handler)
   }
 
-  override fun dispatchTouchEvent(event: MotionEvent) = if (rootViewEnabled && rootHelper!!.dispatchTouchEvent(event)) {
-    true
-  } else {
-    super.dispatchTouchEvent(event)
+  override fun dispatchTouchEvent(event: MotionEvent): Boolean {
+    // When starting a new event stream, dispatch CANCEL event so the subtree
+    // can clean up its internal state that may be stale due to Gesture Handler
+    // starting to intercept events mid-stream.
+    if (rootViewEnabled && event.actionMasked == MotionEvent.ACTION_DOWN) {
+      val cancelEvent = MotionEvent.obtain(event).apply { action = MotionEvent.ACTION_CANCEL }
+      super.dispatchTouchEvent(cancelEvent)
+      cancelEvent.recycle()
+    }
+
+    return if (rootViewEnabled && rootHelper!!.dispatchTouchEvent(event)) {
+      true
+    } else {
+      super.dispatchTouchEvent(event)
+    }
   }
 
   override fun dispatchGenericMotionEvent(ev: MotionEvent) =

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

@@ -38,12 +38,6 @@ class RNViewConfigurationHelper : ViewConfigurationHelper {
     }
   }
 
-  override fun getChildInDrawingOrderAtIndex(parent: ViewGroup, index: Int): View = if (parent is ReactViewGroup) {
-    parent.getChildAt(parent.getZIndexMappedChildIndex(index))
-  } else {
-    parent.getChildAt(index)
-  }
-
   override fun isViewClippingChildren(view: ViewGroup) = when {
     view.clipChildren -> true
     view is ReactScrollView -> view.overflow != "visible"

package/apple/Handlers/RNForceTouchHandler.m

@@ -170,7 +170,7 @@ static const BOOL defaultFeedbackOnActivation = NO;
 - (RNGestureHandlerEventExtraData *)eventExtraData:(RNForceTouchGestureRecognizer *)recognizer
 {
   return [RNGestureHandlerEventExtraData forForce:recognizer.force
-                                      forPosition:[recognizer locationInView:recognizer.view]
+                                      forPosition:[recognizer locationInView:self.coordinateView]
                              withAbsolutePosition:[recognizer locationInView:recognizer.view.window]
                               withNumberOfTouches:recognizer.numberOfTouches
                                   withPointerType:_pointerType];

package/apple/Handlers/RNHoverHandler.m

@@ -56,16 +56,6 @@ API_AVAILABLE(ios(13.4))
   [_gestureHandler handleGesture:self];
 }
 
-- (void)triggerAction
-{
-  [_gestureHandler handleGesture:self fromReset:NO fromManualStateChange:NO];
-}
-
-- (void)cancel
-{
-  self.enabled = NO;
-}
-
 - (void)reset
 {
   [super reset];
@@ -177,11 +167,16 @@ API_AVAILABLE(ios(13.4))
 
 - (RNGestureHandlerEventExtraData *)eventExtraData:(UIGestureRecognizer *)recognizer
 {
-  return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:recognizer.view]
+  return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:self.coordinateView]
                                 withAbsolutePosition:[recognizer locationInView:recognizer.view.window]
                                      withPointerType:_pointerType];
 }
 
+- (BOOL)isContinuous
+{
+  return YES;
+}
+
 @end
 
 #else
@@ -201,6 +196,11 @@ API_AVAILABLE(ios(13.4))
   return self;
 }
 
+- (BOOL)isContinuous
+{
+  return YES;
+}
+
 - (void)bindToView:(RNGHUIView *)view
 {
   _view = view;

package/apple/Handlers/RNLongPressHandler.m

@@ -287,7 +287,7 @@
 
 - (RNGestureHandlerEventExtraData *)eventExtraData:(UIGestureRecognizer *)recognizer
 {
-  return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:recognizer.view]
+  return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:self.coordinateView]
                                 withAbsolutePosition:[recognizer locationInView:recognizer.view.window]
                                  withNumberOfTouches:recognizer.numberOfTouches
                                         withDuration:[(RNBetterLongPressGestureRecognizer *)recognizer getDuration]
@@ -298,7 +298,7 @@
 
 - (RNGestureHandlerEventExtraData *)eventExtraData:(NSGestureRecognizer *)recognizer
 {
-  return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:recognizer.view]
+  return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:self.coordinateView]
                                 withAbsolutePosition:[recognizer locationInView:recognizer.view.window.contentView]
                                  withNumberOfTouches:1
                                         withDuration:[(RNBetterLongPressGestureRecognizer *)recognizer getDuration]

package/apple/Handlers/RNManualHandler.m

@@ -135,4 +135,9 @@
   return self;
 }
 
+- (BOOL)isContinuous
+{
+  return YES;
+}
+
 @end