react-native-gesture-handler 2.25.0 → 2.27.0

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

@@ -20,9 +20,9 @@ class GestureHandlerOrchestrator(
    * traversing view hierarchy and looking for gesture handlers.
    */
   var minimumAlphaForTraversal = DEFAULT_MIN_ALPHA_FOR_TRAVERSAL
-  private val gestureHandlers = arrayListOf<GestureHandler<*>>()
-  private val awaitingHandlers = arrayListOf<GestureHandler<*>>()
-  private val preparedHandlers = arrayListOf<GestureHandler<*>>()
+  private val gestureHandlers = arrayListOf<GestureHandler>()
+  private val awaitingHandlers = arrayListOf<GestureHandler>()
+  private val preparedHandlers = arrayListOf<GestureHandler>()
 
   // In `onHandlerStateChange` method we iterate through `awaitingHandlers`, but calling `tryActivate` may modify this list.
   // To avoid `ConcurrentModificationException` we iterate through copy. There is one more problem though - if handler was
@@ -42,7 +42,10 @@ class GestureHandlerOrchestrator(
   fun onTouchEvent(event: MotionEvent): Boolean {
     isHandlingTouch = true
     val action = event.actionMasked
-    if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_POINTER_DOWN || action == MotionEvent.ACTION_HOVER_MOVE) {
+    if (action == MotionEvent.ACTION_DOWN ||
+      action == MotionEvent.ACTION_POINTER_DOWN ||
+      action == MotionEvent.ACTION_HOVER_MOVE
+    ) {
       extractGestureHandlers(event)
     } else if (action == MotionEvent.ACTION_CANCEL) {
       cancelAll()
@@ -82,16 +85,20 @@ class GestureHandlerOrchestrator(
     finishedHandlersCleanupScheduled = false
   }
 
-  private fun hasOtherHandlerToWaitFor(handler: GestureHandler<*>) =
+  private fun hasOtherHandlerToWaitFor(handler: GestureHandler) =
     gestureHandlers.any { !isFinished(it.state) && shouldHandlerWaitForOther(handler, it) }
 
-  private fun shouldBeCancelledByFinishedHandler(handler: GestureHandler<*>) =
+  private fun shouldBeCancelledByFinishedHandler(handler: GestureHandler) =
     gestureHandlers.any { shouldHandlerWaitForOther(handler, it) && it.state == GestureHandler.STATE_END }
 
-  private fun shouldBeCancelledByActiveHandler(handler: GestureHandler<*>) =
-    gestureHandlers.any { handler.hasCommonPointers(it) && it.state == GestureHandler.STATE_ACTIVE && !canRunSimultaneously(handler, it) && handler.isDescendantOf(it) }
+  private fun shouldBeCancelledByActiveHandler(handler: GestureHandler) = gestureHandlers.any {
+    handler.hasCommonPointers(it) &&
+      it.state == GestureHandler.STATE_ACTIVE &&
+      !canRunSimultaneously(handler, it) &&
+      handler.isDescendantOf(it)
+  }
 
-  private fun tryActivate(handler: GestureHandler<*>) {
+  private fun tryActivate(handler: GestureHandler) {
     // If we are waiting for a gesture that has successfully finished, we should cancel handler
     if (shouldBeCancelledByFinishedHandler(handler) || shouldBeCancelledByActiveHandler(handler)) {
       handler.cancel()
@@ -120,7 +127,7 @@ class GestureHandlerOrchestrator(
   }
 
   /*package*/
-  fun onHandlerStateChange(handler: GestureHandler<*>, newState: Int, prevState: Int) {
+  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
@@ -129,7 +136,9 @@ class GestureHandlerOrchestrator(
 
       // if there were handlers awaiting completion of this handler, we can trigger active state
       for (otherHandler in currentlyAwaitingHandlers) {
-        if (!shouldHandlerWaitForOther(otherHandler, handler) || !awaitingHandlersTags.contains(otherHandler.tag)) {
+        if (!shouldHandlerWaitForOther(otherHandler, handler) ||
+          !awaitingHandlersTags.contains(otherHandler.tag)
+        ) {
           continue
         }
 
@@ -143,7 +152,7 @@ class GestureHandlerOrchestrator(
             // Send synthetic BEGAN -> CANCELLED to properly handle JS logic
             otherHandler.dispatchStateChange(
               GestureHandler.STATE_CANCELLED,
-              GestureHandler.STATE_BEGAN
+              GestureHandler.STATE_BEGAN,
             )
           }
           otherHandler.isAwaiting = false
@@ -159,7 +168,9 @@ 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 && (newState == GestureHandler.STATE_CANCELLED || newState == GestureHandler.STATE_FAILED)) {
+      } 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
@@ -167,7 +178,9 @@ class GestureHandlerOrchestrator(
         // makeActive method.
         handler.dispatchStateChange(newState, GestureHandler.STATE_BEGAN)
       }
-    } else if (prevState != GestureHandler.STATE_UNDETERMINED || newState != GestureHandler.STATE_CANCELLED) {
+    } else if (prevState != GestureHandler.STATE_UNDETERMINED ||
+      newState != GestureHandler.STATE_CANCELLED
+    ) {
       // If handler is changing state from UNDETERMINED to CANCELLED, the state change event shouldn't
       // be sent. Handler hasn't yet began so it may not be initialized which results in crashes.
       // If it doesn't crash, there may be some weird behavior on JS side, as `onFinalize` will be
@@ -178,7 +191,7 @@ class GestureHandlerOrchestrator(
     scheduleFinishedHandlersCleanup()
   }
 
-  private fun makeActive(handler: GestureHandler<*>) {
+  private fun makeActive(handler: GestureHandler) {
     val currentState = handler.state
     with(handler) {
       isAwaiting = false
@@ -208,7 +221,9 @@ class GestureHandlerOrchestrator(
     // 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) {
+    if (currentState == GestureHandler.STATE_FAILED ||
+      currentState == GestureHandler.STATE_CANCELLED
+    ) {
       return
     }
 
@@ -253,7 +268,7 @@ class GestureHandlerOrchestrator(
     }
   }
 
-  private fun deliverEventToGestureHandler(handler: GestureHandler<*>, sourceEvent: MotionEvent) {
+  private fun deliverEventToGestureHandler(handler: GestureHandler, sourceEvent: MotionEvent) {
     if (!isViewAttachedUnderWrapper(handler.view)) {
       handler.cancel()
       return
@@ -301,7 +316,10 @@ class GestureHandlerOrchestrator(
 
       // if event was of type UP or POINTER_UP we request handler to stop tracking now that
       // the event has been dispatched
-      if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_HOVER_EXIT) {
+      if (action == MotionEvent.ACTION_UP ||
+        action == MotionEvent.ACTION_POINTER_UP ||
+        action == MotionEvent.ACTION_HOVER_EXIT
+      ) {
         val pointerId = event.getPointerId(event.actionIndex)
         handler.stopTrackingPointer(pointerId)
       }
@@ -404,7 +422,7 @@ class GestureHandlerOrchestrator(
     return point
   }
 
-  private fun addAwaitingHandler(handler: GestureHandler<*>) {
+  private fun addAwaitingHandler(handler: GestureHandler) {
     if (awaitingHandlers.contains(handler)) {
       return
     }
@@ -418,7 +436,7 @@ class GestureHandlerOrchestrator(
     }
   }
 
-  private fun recordHandlerIfNotPresent(handler: GestureHandler<*>, view: View) {
+  private fun recordHandlerIfNotPresent(handler: GestureHandler, view: View) {
     if (gestureHandlers.contains(handler)) {
       return
     }
@@ -440,7 +458,10 @@ class GestureHandlerOrchestrator(
     val left = localXY[0] + view.left
     val top = localXY[1] + view.top
 
-    return left < 0f || left + view.width > parent.width || top < 0f || top + view.height > parent.height
+    return left < 0f ||
+      left + view.width > parent.width ||
+      top < 0f ||
+      top + view.height > parent.height
   }
 
   private fun extractAncestorHandlers(view: View, coords: FloatArray, pointerId: Int): Boolean {
@@ -474,14 +495,26 @@ class GestureHandlerOrchestrator(
   // There's only one exception - RootViewGestureHandler. TalkBack uses hover events,
   // so we need to pass them into RootViewGestureHandler, otherwise press and hold
   // gesture stops working correctly (see https://github.com/software-mansion/react-native-gesture-handler/issues/3407)
-  private fun shouldHandlerSkipHoverEvents(handler: GestureHandler<*>, action: Int): Boolean {
+  private fun shouldHandlerSkipHoverEvents(handler: GestureHandler, action: Int): Boolean {
     val shouldSkipHoverEvents =
-      handler !is HoverGestureHandler && handler !is RNGestureHandlerRootHelper.RootViewGestureHandler
-
-    return shouldSkipHoverEvents && action in listOf(MotionEvent.ACTION_HOVER_EXIT, MotionEvent.ACTION_HOVER_ENTER, MotionEvent.ACTION_HOVER_MOVE)
+      handler !is HoverGestureHandler &&
+        handler !is RNGestureHandlerRootHelper.RootViewGestureHandler
+
+    return shouldSkipHoverEvents &&
+      action in
+      listOf(
+        MotionEvent.ACTION_HOVER_EXIT,
+        MotionEvent.ACTION_HOVER_ENTER,
+        MotionEvent.ACTION_HOVER_MOVE,
+      )
   }
 
-  private fun recordViewHandlersForPointer(view: View, coords: FloatArray, pointerId: Int, event: MotionEvent): Boolean {
+  private fun recordViewHandlersForPointer(
+    view: View,
+    coords: FloatArray,
+    pointerId: Int,
+    event: MotionEvent,
+  ): Boolean {
     var found = false
     handlerRegistry.getHandlersForView(view)?.let {
       synchronized(it) {
@@ -504,8 +537,10 @@ class GestureHandlerOrchestrator(
 
     // if the pointer is inside the view but it overflows its parent, handlers attached to the parent
     // might not have been extracted (pointer might be in a child, but may be outside parent)
-    if (coords[0] in 0f..view.width.toFloat() && coords[1] in 0f..view.height.toFloat() &&
-      isViewOverflowingParent(view) && extractAncestorHandlers(view, coords, pointerId)
+    if (coords[0] in 0f..view.width.toFloat() &&
+      coords[1] in 0f..view.height.toFloat() &&
+      isViewOverflowingParent(view) &&
+      extractAncestorHandlers(view, coords, pointerId)
     ) {
       found = true
     }
@@ -522,7 +557,12 @@ class GestureHandlerOrchestrator(
     extractGestureHandlers(wrapperView, tempCoords, pointerId, event)
   }
 
-  private fun extractGestureHandlers(viewGroup: ViewGroup, coords: FloatArray, pointerId: Int, event: MotionEvent): Boolean {
+  private fun extractGestureHandlers(
+    viewGroup: ViewGroup,
+    coords: FloatArray,
+    pointerId: Int,
+    event: MotionEvent,
+  ): Boolean {
     val childrenCount = viewGroup.childCount
     for (i in childrenCount - 1 downTo 0) {
       val child = viewConfigHelper.getChildInDrawingOrderAtIndex(viewGroup, i)
@@ -587,22 +627,23 @@ class GestureHandlerOrchestrator(
         // Either this view or one of its children is the target
         val found = if (view is ViewGroup) {
           extractGestureHandlers(view, coords, pointerId, event)
-        } else false
+        } else {
+          false
+        }
 
         (
           recordViewHandlersForPointer(view, coords, pointerId, event) ||
-            found || shouldHandlerlessViewBecomeTouchTarget(view, coords)
+            found ||
+            shouldHandlerlessViewBecomeTouchTarget(view, coords)
           )
       }
     }
 
-  private fun canReceiveEvents(view: View) =
-    view.visibility == View.VISIBLE && view.alpha >= minimumAlphaForTraversal
+  private fun canReceiveEvents(view: View) = view.visibility == View.VISIBLE && view.alpha >= minimumAlphaForTraversal
 
   // if view is not a view group it is clipping, otherwise we check for `getClipChildren` flag to
   // be turned on and also confirm with the ViewConfigHelper implementation
-  private fun isClipping(view: View) =
-    view !is ViewGroup || viewConfigHelper.isViewClippingChildren(view)
+  private fun isClipping(view: View) = view !is ViewGroup || viewConfigHelper.isViewClippingChildren(view)
 
   fun activateNativeHandlersForView(view: View) {
     handlerRegistry.getHandlersForView(view)?.forEach {
@@ -629,7 +670,7 @@ class GestureHandlerOrchestrator(
     private val matrixTransformCoords = FloatArray(2)
     private val inverseMatrix = Matrix()
     private val tempCoords = FloatArray(2)
-    private val handlersComparator = Comparator<GestureHandler<*>> { a, b ->
+    private val handlersComparator = Comparator<GestureHandler> { a, b ->
       return@Comparator if (a.isActive && b.isActive || a.isAwaiting && b.isAwaiting) {
         // both A and B are either active or awaiting activation, in which case we prefer one that
         // has activated (or turned into "awaiting" state) earlier
@@ -683,17 +724,17 @@ class GestureHandlerOrchestrator(
     private fun isTransformedTouchPointInView(x: Float, y: Float, child: View) =
       x in 0f..child.width.toFloat() && y in 0f..child.height.toFloat()
 
-    private fun shouldHandlerWaitForOther(handler: GestureHandler<*>, other: GestureHandler<*>): Boolean {
-      return handler !== other && (
-        handler.shouldWaitForHandlerFailure(other) ||
-          other.shouldRequireToWaitForFailure(handler)
-        )
-    }
+    private fun shouldHandlerWaitForOther(handler: GestureHandler, other: GestureHandler): Boolean =
+      handler !== other &&
+        (
+          handler.shouldWaitForHandlerFailure(other) ||
+            other.shouldRequireToWaitForFailure(handler)
+          )
 
-    private fun canRunSimultaneously(a: GestureHandler<*>, b: GestureHandler<*>) =
+    private fun canRunSimultaneously(a: GestureHandler, b: GestureHandler) =
       a === b || a.shouldRecognizeSimultaneously(b) || b.shouldRecognizeSimultaneously(a)
 
-    private fun shouldHandlerBeCancelledBy(handler: GestureHandler<*>, other: GestureHandler<*>): Boolean {
+    private fun shouldHandlerBeCancelledBy(handler: GestureHandler, other: GestureHandler): Boolean {
       if (!handler.hasCommonPointers(other)) {
         // if two handlers share no common pointer one can never trigger cancel for the other
         return false
@@ -709,12 +750,13 @@ class GestureHandlerOrchestrator(
         // in every other case as long as the handler is about to be activated or already in active
         // state, we delegate the decision to the implementation of GestureHandler#shouldBeCancelledBy
         handler.shouldBeCancelledBy(other)
-      } else true
+      } else {
+        true
+      }
     }
 
-    private fun isFinished(state: Int) =
-      state == GestureHandler.STATE_CANCELLED ||
-        state == GestureHandler.STATE_FAILED ||
-        state == GestureHandler.STATE_END
+    private fun isFinished(state: Int) = state == GestureHandler.STATE_CANCELLED ||
+      state == GestureHandler.STATE_FAILED ||
+      state == GestureHandler.STATE_END
   }
 }

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

@@ -4,5 +4,5 @@ import android.view.View
 import java.util.*
 
 interface GestureHandlerRegistry {
-  fun getHandlersForView(view: View): ArrayList<GestureHandler<*>>?
+  fun getHandlersForView(view: View): ArrayList<GestureHandler>?
 }

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

@@ -5,7 +5,11 @@ import kotlin.math.cos
 
 object GestureUtils {
   fun getLastPointerX(event: MotionEvent, averageTouches: Boolean): Float {
-    val excludeIndex = if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) event.actionIndex else -1
+    val excludeIndex = if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) {
+      event.actionIndex
+    } else {
+      -1
+    }
     return if (averageTouches) {
       var sum = 0f
       var count = 0
@@ -26,7 +30,13 @@ object GestureUtils {
   }
 
   fun getLastPointerY(event: MotionEvent, averageTouches: Boolean): Float {
-    val excludeIndex = if (event.actionMasked == MotionEvent.ACTION_POINTER_UP) event.actionIndex else -1
+    val excludeIndex = if (event.actionMasked ==
+      MotionEvent.ACTION_POINTER_UP
+    ) {
+      event.actionIndex
+    } else {
+      -1
+    }
     return if (averageTouches) {
       var sum = 0f
       var count = 0
@@ -46,6 +56,5 @@ object GestureUtils {
     }
   }
 
-  fun coneToDeviation(angle: Double): Double =
-    cos(Math.toRadians(angle / 2.0))
+  fun coneToDeviation(angle: Double): Double = cos(Math.toRadians(angle / 2.0))
 }

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

@@ -1,5 +1,6 @@
 package com.swmansion.gesturehandler.core
 
+import android.content.Context
 import android.os.Handler
 import android.os.Looper
 import android.view.MotionEvent
@@ -7,14 +8,15 @@ import android.view.View
 import android.view.ViewGroup
 import com.swmansion.gesturehandler.react.RNGestureHandlerRootHelper
 import com.swmansion.gesturehandler.react.RNViewConfigurationHelper
+import com.swmansion.gesturehandler.react.eventbuilders.HoverGestureHandlerEventDataBuilder
 
-class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
+class HoverGestureHandler : GestureHandler() {
   private var handler: Handler? = null
   private var finishRunnable = Runnable { finish() }
   var stylusData: StylusData = StylusData()
     private set
 
-  private infix fun isAncestorOf(other: GestureHandler<*>): Boolean {
+  private infix fun isAncestorOf(other: GestureHandler): Boolean {
     var current: View? = other.view
 
     while (current != null) {
@@ -48,7 +50,7 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
     return null
   }
 
-  override fun shouldBeCancelledBy(handler: GestureHandler<*>): Boolean {
+  override fun shouldBeCancelledBy(handler: GestureHandler): Boolean {
     if (handler is HoverGestureHandler && !(handler isAncestorOf this)) {
       return isViewDisplayedOverAnother(handler.view!!, this.view!!)!!
     }
@@ -56,7 +58,7 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
     return super.shouldBeCancelledBy(handler)
   }
 
-  override fun shouldRequireToWaitForFailure(handler: GestureHandler<*>): Boolean {
+  override fun shouldRequireToWaitForFailure(handler: GestureHandler): Boolean {
     if (handler is HoverGestureHandler) {
       if (!(this isAncestorOf handler) && !(handler isAncestorOf this)) {
         isViewDisplayedOverAnother(this.view!!, handler.view!!)?.let {
@@ -68,7 +70,7 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
     return super.shouldRequireToWaitForFailure(handler)
   }
 
-  override fun shouldRecognizeSimultaneously(handler: GestureHandler<*>): Boolean {
+  override fun shouldRecognizeSimultaneously(handler: GestureHandler): Boolean {
     if (handler is HoverGestureHandler && (this isAncestorOf handler || handler isAncestorOf this)) {
       return true
     }
@@ -110,7 +112,10 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
       }
 
       this.state == STATE_UNDETERMINED &&
-        (event.action == MotionEvent.ACTION_HOVER_MOVE || event.action == MotionEvent.ACTION_HOVER_ENTER) -> {
+        (
+          event.action == MotionEvent.ACTION_HOVER_MOVE ||
+            event.action == MotionEvent.ACTION_HOVER_ENTER
+          ) -> {
         begin()
         activate()
       }
@@ -130,6 +135,15 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
     }
   }
 
+  class Factory : GestureHandler.Factory<HoverGestureHandler>() {
+    override val type = HoverGestureHandler::class.java
+    override val name = "HoverGestureHandler"
+
+    override fun create(context: Context?): HoverGestureHandler = HoverGestureHandler()
+
+    override fun createEventBuilder(handler: HoverGestureHandler) = HoverGestureHandlerEventDataBuilder(handler)
+  }
+
   companion object {
     private val viewConfigHelper = RNViewConfigurationHelper()
   }

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

@@ -5,13 +5,16 @@ import android.os.Handler
 import android.os.Looper
 import android.os.SystemClock
 import android.view.MotionEvent
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.react.eventbuilders.LongPressGestureHandlerEventDataBuilder
 
-class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestureHandler>() {
+class LongPressGestureHandler(context: Context) : GestureHandler() {
   var minDurationMs = DEFAULT_MIN_DURATION_MS
   val duration: Int
     get() = (previousTime - startTime).toInt()
-  private val defaultMaxDistSq: Float
-  private var maxDistSq: Float
+  private val defaultMaxDist: Float
+  private var maxDist: Float
   private var numberOfPointersRequired: Int
   private var startX = 0f
   private var startY = 0f
@@ -21,28 +24,19 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
   private var currentPointers = 0
 
   init {
-    setShouldCancelWhenOutside(true)
+    shouldCancelWhenOutside = true
 
-    val defaultMaxDist = DEFAULT_MAX_DIST_DP * context.resources.displayMetrics.density
-    defaultMaxDistSq = defaultMaxDist * defaultMaxDist
-    maxDistSq = defaultMaxDistSq
+    val systemDefaultMaxDist = DEFAULT_MAX_DIST_DP * context.resources.displayMetrics.density
+    defaultMaxDist = systemDefaultMaxDist
+    maxDist = defaultMaxDist
     numberOfPointersRequired = 1
   }
 
   override fun resetConfig() {
     super.resetConfig()
     minDurationMs = DEFAULT_MIN_DURATION_MS
-    maxDistSq = defaultMaxDistSq
-  }
-
-  fun setMaxDist(maxDist: Float): LongPressGestureHandler {
-    maxDistSq = maxDist * maxDist
-    return this
-  }
-
-  fun setNumberOfPointers(numberOfPointers: Int): LongPressGestureHandler {
-    numberOfPointersRequired = numberOfPointers
-    return this
+    maxDist = defaultMaxDist
+    shouldCancelWhenOutside = DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE
   }
 
   private fun getAverageCoords(ev: MotionEvent, excludePointer: Boolean = false): Pair<Float, Float> {
@@ -101,7 +95,13 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
       }
     }
 
-    if (state == STATE_BEGAN && currentPointers == numberOfPointersRequired && (sourceEvent.actionMasked == MotionEvent.ACTION_DOWN || sourceEvent.actionMasked == MotionEvent.ACTION_POINTER_DOWN)) {
+    if (state == STATE_BEGAN &&
+      currentPointers == numberOfPointersRequired &&
+      (
+        sourceEvent.actionMasked == MotionEvent.ACTION_DOWN ||
+          sourceEvent.actionMasked == MotionEvent.ACTION_POINTER_DOWN
+        )
+    ) {
       handler = Handler(Looper.getMainLooper())
       if (minDurationMs > 0) {
         handler!!.postDelayed({ activate() }, minDurationMs)
@@ -109,7 +109,9 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
         activate()
       }
     }
-    if (sourceEvent.actionMasked == MotionEvent.ACTION_UP || sourceEvent.actionMasked == MotionEvent.ACTION_BUTTON_RELEASE) {
+    if (sourceEvent.actionMasked == MotionEvent.ACTION_UP ||
+      sourceEvent.actionMasked == MotionEvent.ACTION_BUTTON_RELEASE
+    ) {
       currentPointers--
 
       handler?.let {
@@ -141,7 +143,7 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
       val deltaY = y - startY
       val distSq = deltaX * deltaX + deltaY * deltaY
 
-      if (distSq > maxDistSq) {
+      if (distSq > maxDist * maxDist) {
         if (state == STATE_ACTIVE) {
           cancel()
         } else {
@@ -173,7 +175,36 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
     currentPointers = 0
   }
 
+  class Factory : GestureHandler.Factory<LongPressGestureHandler>() {
+    override val type = LongPressGestureHandler::class.java
+    override val name = "LongPressGestureHandler"
+
+    override fun create(context: Context?): LongPressGestureHandler = LongPressGestureHandler((context)!!)
+
+    override fun setConfig(handler: LongPressGestureHandler, config: ReadableMap) {
+      super.setConfig(handler, config)
+      if (config.hasKey(KEY_MIN_DURATION_MS)) {
+        handler.minDurationMs = config.getInt(KEY_MIN_DURATION_MS).toLong()
+      }
+      if (config.hasKey(KEY_MAX_DIST)) {
+        handler.maxDist = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MAX_DIST))
+      }
+      if (config.hasKey(KEY_NUMBER_OF_POINTERS)) {
+        handler.numberOfPointers = config.getInt(KEY_NUMBER_OF_POINTERS)
+      }
+    }
+
+    override fun createEventBuilder(handler: LongPressGestureHandler) = LongPressGestureHandlerEventDataBuilder(handler)
+
+    companion object {
+      private const val KEY_MIN_DURATION_MS = "minDurationMs"
+      private const val KEY_MAX_DIST = "maxDist"
+      private const val KEY_NUMBER_OF_POINTERS = "numberOfPointers"
+    }
+  }
+
   companion object {
+    private const val DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE = true
     private const val DEFAULT_MIN_DURATION_MS: Long = 500
     private const val DEFAULT_MAX_DIST_DP = 10f
   }

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

@@ -1,11 +1,22 @@
 package com.swmansion.gesturehandler.core
 
+import android.content.Context
 import android.view.MotionEvent
+import com.swmansion.gesturehandler.react.eventbuilders.ManualGestureHandlerEventDataBuilder
 
-class ManualGestureHandler : GestureHandler<ManualGestureHandler>() {
+class ManualGestureHandler : GestureHandler() {
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     if (state == STATE_UNDETERMINED) {
       begin()
     }
   }
+
+  class Factory : GestureHandler.Factory<ManualGestureHandler>() {
+    override val type = ManualGestureHandler::class.java
+    override val name = "ManualGestureHandler"
+
+    override fun create(context: Context?): ManualGestureHandler = ManualGestureHandler()
+
+    override fun createEventBuilder(handler: ManualGestureHandler) = ManualGestureHandlerEventDataBuilder(handler)
+  }
 }