@amazon-devices/react-native-gesture-handler 2.0.1759135970 → 4.0.0-rn-83

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

@@ -4,22 +4,26 @@ import android.app.Activity
 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
 import android.view.View
-import android.view.Window
 import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.uimanager.PixelUtil
 import com.swmansion.gesturehandler.BuildConfig
+import com.swmansion.gesturehandler.RNSVGHitTester
 import com.swmansion.gesturehandler.react.RNGestureHandlerTouchEvent
+import com.swmansion.gesturehandler.react.eventbuilders.GestureHandlerEventDataBuilder
 import java.lang.IllegalStateException
 import java.util.*
 
-open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestureHandlerT>> {
+open class GestureHandler {
   private val trackedPointerIDs = IntArray(MAX_POINTERS_COUNT)
   private var trackedPointersIDsCount = 0
   private val windowOffset = IntArray(2) { 0 }
@@ -35,7 +39,17 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   var isWithinBounds = false
     private set
   var isEnabled = true
-    private set
+    private set(enabled) {
+      // Don't cancel handler when not changing the value of the isEnabled, executing it always caused
+      // handlers to be cancelled on re-render because that's the moment when the config is updated.
+      // If the enabled prop "changed" from true to true the handler would get cancelled.
+      if (view != null && isEnabled != enabled) {
+        // If view is set then handler is in "active" state. In that case we want to "cancel" handler
+        // when it changes enabled state so that it gets cleared from the orchestrator
+        UiThreadUtil.runOnUiThread { cancel() }
+      }
+      field = enabled
+    }
   var actionType = 0
 
   var changedTouchesPayload: WritableArray? = null
@@ -61,18 +75,16 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
 
   private var lastEventOffsetX = 0f
   private var lastEventOffsetY = 0f
-  private var shouldCancelWhenOutside = false
   var numberOfPointers = 0
-    private set
+    protected set
+  protected var shouldCancelWhenOutside = false
   protected var orchestrator: GestureHandlerOrchestrator? = null
-  private var onTouchEventListener: OnTouchEventListener? = null
+  var onTouchEventListener: OnTouchEventListener? = null
   private var interactionController: GestureHandlerInteractionController? = null
+  var pointerType: Int = POINTER_TYPE_OTHER
+    private set
 
-  @Suppress("UNCHECKED_CAST")
-  protected fun self(): ConcreteGestureHandlerT = this as ConcreteGestureHandlerT
-
-  protected inline fun applySelf(block: ConcreteGestureHandlerT.() -> Unit): ConcreteGestureHandlerT =
-    self().apply { block() }
+  protected var mouseButton = 0
 
   // properties set and accessed only by the orchestrator
   var activationIndex = 0
@@ -81,28 +93,29 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   var shouldResetProgress = false
 
   open fun dispatchStateChange(newState: Int, prevState: Int) {
-    onTouchEventListener?.onStateChange(self(), newState, prevState)
+    onTouchEventListener?.onStateChange(this, newState, prevState)
   }
 
   open fun dispatchHandlerUpdate(event: MotionEvent) {
-    onTouchEventListener?.onHandlerUpdate(self(), event)
+    onTouchEventListener?.onHandlerUpdate(this, event)
   }
 
   open fun dispatchTouchEvent() {
     if (changedTouchesPayload != null) {
-      onTouchEventListener?.onTouchEvent(self())
+      onTouchEventListener?.onTouchEvent(this)
     }
   }
 
   open fun resetConfig() {
-    needsPointerData = false
-    manualActivation = false
-    shouldCancelWhenOutside = false
-    isEnabled = true
-    hitSlop = null
+    needsPointerData = DEFAULT_NEEDS_POINTER_DATA
+    manualActivation = DEFAULT_MANUAL_ACTIVATION
+    shouldCancelWhenOutside = DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE
+    isEnabled = DEFAULT_IS_ENABLED
+    hitSlop = DEFAULT_HIT_SLOP
+    mouseButton = DEFAULT_MOUSE_BUTTON
   }
 
-  fun hasCommonPointers(other: GestureHandler<*>): Boolean {
+  fun hasCommonPointers(other: GestureHandler): Boolean {
     for (i in trackedPointerIDs.indices) {
       if (trackedPointerIDs[i] != -1 && other.trackedPointerIDs[i] != -1) {
         return true
@@ -111,32 +124,7 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     return false
   }
 
-  fun setShouldCancelWhenOutside(shouldCancelWhenOutside: Boolean): ConcreteGestureHandlerT =
-    applySelf { this.shouldCancelWhenOutside = shouldCancelWhenOutside }
-
-  fun setEnabled(enabled: Boolean): ConcreteGestureHandlerT = applySelf {
-    // Don't cancel handler when not changing the value of the isEnabled, executing it always caused
-    // handlers to be cancelled on re-render because that's the moment when the config is updated.
-    // If the enabled prop "changed" from true to true the handler would get cancelled.
-    if (view != null && isEnabled != enabled) {
-      // If view is set then handler is in "active" state. In that case we want to "cancel" handler
-      // when it changes enabled state so that it gets cleared from the orchestrator
-      UiThreadUtil.runOnUiThread { cancel() }
-    }
-    isEnabled = enabled
-  }
-
-  fun setManualActivation(manualActivation: Boolean): ConcreteGestureHandlerT =
-    applySelf { this.manualActivation = manualActivation }
-
-  fun setHitSlop(
-    leftPad: Float,
-    topPad: Float,
-    rightPad: Float,
-    bottomPad: Float,
-    width: Float,
-    height: Float,
-  ): ConcreteGestureHandlerT = applySelf {
+  fun setHitSlop(leftPad: Float, topPad: Float, rightPad: Float, bottomPad: Float, width: Float, height: Float) {
     if (hitSlop == null) {
       hitSlop = FloatArray(6)
     }
@@ -146,33 +134,39 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     hitSlop!![HIT_SLOP_BOTTOM_IDX] = bottomPad
     hitSlop!![HIT_SLOP_WIDTH_IDX] = width
     hitSlop!![HIT_SLOP_HEIGHT_IDX] = height
-    require(!(hitSlopSet(width) && hitSlopSet(leftPad) && hitSlopSet(rightPad))) { "Cannot have all of left, right and width defined" }
-    require(!(hitSlopSet(width) && !hitSlopSet(leftPad) && !hitSlopSet(rightPad))) { "When width is set one of left or right pads need to be defined" }
-    require(!(hitSlopSet(height) && hitSlopSet(bottomPad) && hitSlopSet(topPad))) { "Cannot have all of top, bottom and height defined" }
-    require(!(hitSlopSet(height) && !hitSlopSet(bottomPad) && !hitSlopSet(topPad))) { "When height is set one of top or bottom pads need to be defined" }
+    require(!(hitSlopSet(width) && hitSlopSet(leftPad) && hitSlopSet(rightPad))) {
+      "Cannot have all of left, right and width defined"
+    }
+    require(!(hitSlopSet(width) && !hitSlopSet(leftPad) && !hitSlopSet(rightPad))) {
+      "When width is set one of left or right pads need to be defined"
+    }
+    require(!(hitSlopSet(height) && hitSlopSet(bottomPad) && hitSlopSet(topPad))) {
+      "Cannot have all of top, bottom and height defined"
+    }
+    require(!(hitSlopSet(height) && !hitSlopSet(bottomPad) && !hitSlopSet(topPad))) {
+      "When height is set one of top or bottom pads need to be defined"
+    }
   }
 
-  fun setHitSlop(padding: Float): ConcreteGestureHandlerT {
-    return setHitSlop(padding, padding, padding, padding, HIT_SLOP_NONE, HIT_SLOP_NONE)
-  }
+  fun setHitSlop(padding: Float) = setHitSlop(padding, padding, padding, padding, HIT_SLOP_NONE, HIT_SLOP_NONE)
 
-  fun setInteractionController(controller: GestureHandlerInteractionController?): ConcreteGestureHandlerT =
-    applySelf { interactionController = controller }
+  fun setInteractionController(controller: GestureHandlerInteractionController?) {
+    interactionController = controller
+  }
 
   fun prepare(view: View?, orchestrator: GestureHandlerOrchestrator?) {
-    check(!(this.view != null || this.orchestrator != null)) { "Already prepared or hasn't been reset" }
+    check(!(this.view != null || this.orchestrator != null)) {
+      "Already prepared or hasn't been reset"
+    }
     Arrays.fill(trackedPointerIDs, -1)
     trackedPointersIDsCount = 0
     state = STATE_UNDETERMINED
     this.view = view
     this.orchestrator = orchestrator
 
-    val decorView = getWindow(view?.context)?.decorView
-    if (decorView != null) {
-      val frame = Rect()
-      decorView.getWindowVisibleDisplayFrame(frame)
-      windowOffset[0] = frame.left
-      windowOffset[1] = frame.top
+    val content = getActivity(view?.context)?.findViewById<View>(android.R.id.content)
+    if (content != null) {
+      content.getLocationOnScreen(windowOffset)
     } else {
       windowOffset[0] = 0
       windowOffset[1] = 0
@@ -183,12 +177,11 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
 
   protected open fun onPrepare() {}
 
-  private fun getWindow(context: Context?): Window? {
-    if (context == null) return null
-    if (context is Activity) return context.window
-    if (context is ContextWrapper) return getWindow(context.baseContext)
-
-    return null
+  private fun getActivity(context: Context?): Activity? = when (context) {
+    is ReactContext -> context.currentActivity
+    is Activity -> context
+    is ContextWrapper -> getActivity(context.baseContext)
+    else -> null
   }
 
   private fun findNextLocalPointerId(): Int {
@@ -210,19 +203,25 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   }
 
   fun startTrackingPointer(pointerId: Int) {
-    if (trackedPointerIDs[pointerId] == -1) {
-      trackedPointerIDs[pointerId] = findNextLocalPointerId()
-      trackedPointersIDsCount++
+    if (isTrackingPointer(pointerId)) {
+      return
     }
+
+    trackedPointerIDs[pointerId] = findNextLocalPointerId()
+    trackedPointersIDsCount++
   }
 
   fun stopTrackingPointer(pointerId: Int) {
-    if (trackedPointerIDs[pointerId] != -1) {
-      trackedPointerIDs[pointerId] = -1
-      trackedPointersIDsCount--
+    if (!isTrackingPointer(pointerId)) {
+      return
     }
+
+    trackedPointerIDs[pointerId] = -1
+    trackedPointersIDsCount--
   }
 
+  private fun isTrackingPointer(pointerId: Int) = trackedPointerIDs[pointerId] != -1
+
   private fun needAdapt(event: MotionEvent): Boolean {
     if (event.pointerCount != trackedPointersIDsCount) {
       return true
@@ -247,7 +246,11 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
       actionIndex = event.actionIndex
       val actionPointer = event.getPointerId(actionIndex)
       action = if (trackedPointerIDs[actionPointer] != -1) {
-        if (trackedPointersIDsCount == 1) MotionEvent.ACTION_DOWN else MotionEvent.ACTION_POINTER_DOWN
+        if (trackedPointersIDsCount == 1) {
+          MotionEvent.ACTION_DOWN
+        } else {
+          MotionEvent.ACTION_POINTER_DOWN
+        }
       } else {
         MotionEvent.ACTION_MOVE
       }
@@ -255,7 +258,11 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
       actionIndex = event.actionIndex
       val actionPointer = event.getPointerId(actionIndex)
       action = if (trackedPointerIDs[actionPointer] != -1) {
-        if (trackedPointersIDsCount == 1) MotionEvent.ACTION_UP else MotionEvent.ACTION_POINTER_UP
+        if (trackedPointersIDsCount == 1) {
+          MotionEvent.ACTION_UP
+        } else {
+          MotionEvent.ACTION_POINTER_UP
+        }
       } else {
         MotionEvent.ACTION_MOVE
       }
@@ -283,7 +290,9 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
 
     // introduced in 1.11.0, remove if crashes are not reported
     if (pointerProps.isEmpty() || pointerCoords.isEmpty()) {
-      throw IllegalStateException("pointerCoords.size=${pointerCoords.size}, pointerProps.size=${pointerProps.size}")
+      throw IllegalStateException(
+        "pointerCoords.size=${pointerCoords.size}, pointerProps.size=${pointerProps.size}",
+      )
     }
 
     val result: MotionEvent
@@ -302,7 +311,7 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
         event.deviceId,
         event.edgeFlags,
         event.source,
-        event.flags
+        event.flags,
       )
     } catch (e: IllegalArgumentException) {
       throw AdaptEventException(this, event, e)
@@ -313,12 +322,9 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   }
 
   // exception to help debug https://github.com/software-mansion/react-native-gesture-handler/issues/1188
-  class AdaptEventException(
-    handler: GestureHandler<*>,
-    event: MotionEvent,
-    e: IllegalArgumentException
-  ) : Exception(
-    """
+  class AdaptEventException(handler: GestureHandler, event: MotionEvent, e: IllegalArgumentException) :
+    Exception(
+      """
     handler: ${handler::class.simpleName}
     state: ${handler.state}
     view: ${handler.view}
@@ -329,9 +335,9 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     trackedPointersCount: ${handler.trackedPointersIDsCount}
     trackedPointers: ${handler.trackedPointerIDs.joinToString(separator = ", ")}
     while handling event: $event
-    """.trimIndent(),
-    e
-  )
+      """.trimIndent(),
+      e,
+    )
 
   fun handle(transformedEvent: MotionEvent, sourceEvent: MotionEvent) {
     if (!isEnabled ||
@@ -371,6 +377,14 @@ 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
@@ -387,19 +401,19 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
   }
 
-  private fun dispatchTouchDownEvent(event: MotionEvent) {
+  private fun dispatchTouchDownEvent(event: MotionEvent, sourceEvent: MotionEvent) {
     changedTouchesPayload = null
     touchEventType = RNGestureHandlerTouchEvent.EVENT_TOUCH_DOWN
     val pointerId = event.getPointerId(event.actionIndex)
-    val offsetX = event.rawX - event.x
-    val offsetY = event.rawY - event.y
+    val offsetX = sourceEvent.rawX - sourceEvent.x
+    val offsetY = sourceEvent.rawY - sourceEvent.y
 
     trackedPointers[pointerId] = PointerData(
       pointerId,
       event.getX(event.actionIndex),
       event.getY(event.actionIndex),
-      event.getX(event.actionIndex) + offsetX - windowOffset[0],
-      event.getY(event.actionIndex) + offsetY - windowOffset[1],
+      sourceEvent.getX(event.actionIndex) + offsetX - windowOffset[0],
+      sourceEvent.getY(event.actionIndex) + offsetY - windowOffset[1],
     )
     trackedPointersCount++
     addChangedPointer(trackedPointers[pointerId]!!)
@@ -408,20 +422,20 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     dispatchTouchEvent()
   }
 
-  private fun dispatchTouchUpEvent(event: MotionEvent) {
+  private fun dispatchTouchUpEvent(event: MotionEvent, sourceEvent: MotionEvent) {
     extractAllPointersData()
     changedTouchesPayload = null
     touchEventType = RNGestureHandlerTouchEvent.EVENT_TOUCH_UP
     val pointerId = event.getPointerId(event.actionIndex)
-    val offsetX = event.rawX - event.x
-    val offsetY = event.rawY - event.y
+    val offsetX = sourceEvent.rawX - sourceEvent.x
+    val offsetY = sourceEvent.rawY - sourceEvent.y
 
     trackedPointers[pointerId] = PointerData(
       pointerId,
       event.getX(event.actionIndex),
       event.getY(event.actionIndex),
-      event.getX(event.actionIndex) + offsetX - windowOffset[0],
-      event.getY(event.actionIndex) + offsetY - windowOffset[1],
+      sourceEvent.getX(event.actionIndex) + offsetX - windowOffset[0],
+      sourceEvent.getY(event.actionIndex) + offsetY - windowOffset[1],
     )
     addChangedPointer(trackedPointers[pointerId]!!)
     trackedPointers[pointerId] = null
@@ -430,11 +444,11 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     dispatchTouchEvent()
   }
 
-  private fun dispatchTouchMoveEvent(event: MotionEvent) {
+  private fun dispatchTouchMoveEvent(event: MotionEvent, sourceEvent: MotionEvent) {
     changedTouchesPayload = null
     touchEventType = RNGestureHandlerTouchEvent.EVENT_TOUCH_MOVE
-    val offsetX = event.rawX - event.x
-    val offsetY = event.rawY - event.y
+    val offsetX = sourceEvent.rawX - sourceEvent.x
+    val offsetY = sourceEvent.rawY - sourceEvent.y
     var pointersAdded = 0
 
     for (i in 0 until event.pointerCount) {
@@ -444,8 +458,8 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
       if (pointer.x != event.getX(i) || pointer.y != event.getY(i)) {
         pointer.x = event.getX(i)
         pointer.y = event.getY(i)
-        pointer.absoluteX = event.getX(i) + offsetX - windowOffset[0]
-        pointer.absoluteY = event.getY(i) + offsetY - windowOffset[1]
+        pointer.absoluteX = sourceEvent.getX(i) + offsetX - windowOffset[0]
+        pointer.absoluteY = sourceEvent.getY(i) + offsetY - windowOffset[1]
 
         addChangedPointer(pointer)
         pointersAdded++
@@ -461,15 +475,19 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
   }
 
-  fun updatePointerData(event: MotionEvent) {
-    if (event.actionMasked == MotionEvent.ACTION_DOWN || event.actionMasked == MotionEvent.ACTION_POINTER_DOWN) {
-      dispatchTouchDownEvent(event)
-      dispatchTouchMoveEvent(event)
-    } else if (event.actionMasked == MotionEvent.ACTION_UP || event.actionMasked == MotionEvent.ACTION_POINTER_UP) {
-      dispatchTouchMoveEvent(event)
-      dispatchTouchUpEvent(event)
+  fun updatePointerData(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (event.actionMasked == MotionEvent.ACTION_DOWN ||
+      event.actionMasked == MotionEvent.ACTION_POINTER_DOWN
+    ) {
+      dispatchTouchDownEvent(event, sourceEvent)
+      dispatchTouchMoveEvent(event, sourceEvent)
+    } else if (event.actionMasked == MotionEvent.ACTION_UP ||
+      event.actionMasked == MotionEvent.ACTION_POINTER_UP
+    ) {
+      dispatchTouchMoveEvent(event, sourceEvent)
+      dispatchTouchUpEvent(event, sourceEvent)
     } else if (event.actionMasked == MotionEvent.ACTION_MOVE) {
-      dispatchTouchMoveEvent(event)
+      dispatchTouchMoveEvent(event, sourceEvent)
     }
   }
 
@@ -543,7 +561,9 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
 
     // if there are tracked pointers and the gesture is about to end, send event cancelling all pointers
-    if (trackedPointersCount > 0 && (newState == STATE_END || newState == STATE_CANCELLED || newState == STATE_FAILED)) {
+    if (trackedPointersCount > 0 &&
+      (newState == STATE_END || newState == STATE_CANCELLED || newState == STATE_FAILED)
+    ) {
       cancelPointers()
     }
 
@@ -559,15 +579,13 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     onStateChange(newState, oldState)
   }
 
-  fun wantEvents(): Boolean {
-    return isEnabled &&
-      state != STATE_FAILED &&
-      state != STATE_CANCELLED &&
-      state != STATE_END &&
-      trackedPointersIDsCount > 0
-  }
+  fun wantsEvent(event: MotionEvent): Boolean = isEnabled &&
+    state != STATE_FAILED &&
+    state != STATE_CANCELLED &&
+    state != STATE_END &&
+    isTrackingPointer(event.getPointerId(event.actionIndex))
 
-  open fun shouldRequireToWaitForFailure(handler: GestureHandler<*>): Boolean {
+  open fun shouldRequireToWaitForFailure(handler: GestureHandler): Boolean {
     if (handler === this) {
       return false
     }
@@ -575,7 +593,7 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     return interactionController?.shouldRequireHandlerToWaitForFailure(this, handler) ?: false
   }
 
-  fun shouldWaitForHandlerFailure(handler: GestureHandler<*>): Boolean {
+  fun shouldWaitForHandlerFailure(handler: GestureHandler): Boolean {
     if (handler === this) {
       return false
     }
@@ -583,7 +601,7 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     return interactionController?.shouldWaitForHandlerFailure(this, handler) ?: false
   }
 
-  open fun shouldRecognizeSimultaneously(handler: GestureHandler<*>): Boolean {
+  open fun shouldRecognizeSimultaneously(handler: GestureHandler): Boolean {
     if (handler === this) {
       return true
     }
@@ -591,7 +609,7 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     return interactionController?.shouldRecognizeSimultaneously(this, handler) ?: false
   }
 
-  open fun shouldBeCancelledBy(handler: GestureHandler<*>): Boolean {
+  open fun shouldBeCancelledBy(handler: GestureHandler): Boolean {
     if (handler === this) {
       return false
     }
@@ -600,9 +618,13 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   }
 
   fun isWithinBounds(view: View?, posX: Float, posY: Float): Boolean {
+    if (RNSVGHitTester.isSvgElement(view!!)) {
+      return RNSVGHitTester.hitTest(view, posX, posY)
+    }
+
     var left = 0f
     var top = 0f
-    var right = view!!.width.toFloat()
+    var right = view.width.toFloat()
     var bottom = view.height.toFloat()
     hitSlop?.let { hitSlop ->
       val padLeft = hitSlop[HIT_SLOP_LEFT_IDX]
@@ -642,7 +664,11 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   }
 
   fun cancel() {
-    if (state == STATE_ACTIVE || state == STATE_UNDETERMINED || state == STATE_BEGAN) {
+    if (state == STATE_ACTIVE ||
+      state == STATE_UNDETERMINED ||
+      state == STATE_BEGAN ||
+      this.isAwaiting
+    ) {
       onCancel()
       moveToState(STATE_CANCELLED)
     }
@@ -650,6 +676,7 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
 
   fun fail() {
     if (state == STATE_ACTIVE || state == STATE_UNDETERMINED || state == STATE_BEGAN) {
+      onFail()
       moveToState(STATE_FAILED)
     }
   }
@@ -674,6 +701,22 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
   }
 
+  /*
+   * Returns true if the view this handler is attached to is a descendant of the view the other handler
+   * is attached to and false otherwise.
+   */
+  fun isDescendantOf(of: GestureHandler): Boolean {
+    var view = this.view?.parent as? View
+    while (view != null) {
+      if (view == of.view) {
+        return true
+      }
+
+      view = view.parent as? View
+    }
+    return false
+  }
+
   // responsible for resetting the state of handler upon activation (may be called more than once
   // if the handler is waiting for failure of other one)
   open fun resetProgress() {}
@@ -687,6 +730,55 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   protected open fun onStateChange(newState: Int, previousState: Int) {}
   protected open fun onReset() {}
   protected open fun onCancel() {}
+  protected open fun onFail() {}
+
+  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
@@ -696,19 +788,17 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
    *
    * This method modifies and transforms the received point.
    */
-  protected fun transformPoint(point: PointF): PointF {
-    return orchestrator?.transformPointToViewCoords(this.view, point) ?: run {
+  protected fun transformPoint(point: PointF): PointF =
+    orchestrator?.transformPointToViewCoords(this.view, point) ?: run {
       point.x = Float.NaN
       point.y = Float.NaN
       point
     }
-  }
   fun reset() {
     view = null
     orchestrator = null
     Arrays.fill(trackedPointerIDs, -1)
     trackedPointersIDsCount = 0
-
     trackedPointersCount = 0
     trackedPointers.fill(null)
     touchEventType = RNGestureHandlerTouchEvent.EVENT_UNDETERMINED
@@ -721,9 +811,15 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     isWithinBounds = false
   }
 
-  fun setOnTouchEventListener(listener: OnTouchEventListener?): GestureHandler<*> {
-    onTouchEventListener = listener
-    return this
+  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
+    }
   }
 
   override fun toString(): String {
@@ -741,7 +837,115 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   val lastPositionInWindowY: Float
     get() = lastAbsolutePositionY + lastEventOffsetY - windowOffset[1]
 
+  abstract class Factory<T : GestureHandler> {
+    abstract val type: Class<T>
+    abstract val name: String
+
+    protected abstract fun create(context: Context?): T
+
+    fun create(context: Context?, handlerTag: Int): T = create(context).also { it.tag = handlerTag }
+
+    open fun setConfig(handler: T, config: ReadableMap) {
+      handler.resetConfig()
+      if (config.hasKey(KEY_SHOULD_CANCEL_WHEN_OUTSIDE)) {
+        handler.shouldCancelWhenOutside = config.getBoolean(KEY_SHOULD_CANCEL_WHEN_OUTSIDE)
+      }
+      if (config.hasKey(KEY_ENABLED)) {
+        handler.isEnabled = config.getBoolean(KEY_ENABLED)
+      }
+      if (config.hasKey(KEY_HIT_SLOP)) {
+        handleHitSlopProperty(handler, config)
+      }
+      if (config.hasKey(KEY_NEEDS_POINTER_DATA)) {
+        handler.needsPointerData = config.getBoolean(KEY_NEEDS_POINTER_DATA)
+      }
+      if (config.hasKey(KEY_MANUAL_ACTIVATION)) {
+        handler.manualActivation = config.getBoolean(KEY_MANUAL_ACTIVATION)
+      }
+      if (config.hasKey(KEY_MOUSE_BUTTON)) {
+        handler.mouseButton = config.getInt(KEY_MOUSE_BUTTON)
+      }
+    }
+
+    abstract fun createEventBuilder(handler: T): GestureHandlerEventDataBuilder<T>
+
+    companion object {
+      private const val KEY_SHOULD_CANCEL_WHEN_OUTSIDE = "shouldCancelWhenOutside"
+      private const val KEY_ENABLED = "enabled"
+      private const val KEY_NEEDS_POINTER_DATA = "needsPointerData"
+      private const val KEY_MANUAL_ACTIVATION = "manualActivation"
+      private const val KEY_MOUSE_BUTTON = "mouseButton"
+      private const val KEY_HIT_SLOP = "hitSlop"
+      private const val KEY_HIT_SLOP_LEFT = "left"
+      private const val KEY_HIT_SLOP_TOP = "top"
+      private const val KEY_HIT_SLOP_RIGHT = "right"
+      private const val KEY_HIT_SLOP_BOTTOM = "bottom"
+      private const val KEY_HIT_SLOP_VERTICAL = "vertical"
+      private const val KEY_HIT_SLOP_HORIZONTAL = "horizontal"
+      private const val KEY_HIT_SLOP_WIDTH = "width"
+      private const val KEY_HIT_SLOP_HEIGHT = "height"
+
+      private fun handleHitSlopProperty(handler: GestureHandler, config: ReadableMap) {
+        if (config.getType(KEY_HIT_SLOP) == ReadableType.Number) {
+          val hitSlop = PixelUtil.toPixelFromDIP(config.getDouble(KEY_HIT_SLOP))
+          handler.setHitSlop(
+            hitSlop,
+            hitSlop,
+            hitSlop,
+            hitSlop,
+            GestureHandler.HIT_SLOP_NONE,
+            GestureHandler.HIT_SLOP_NONE,
+          )
+        } else {
+          val hitSlop = config.getMap(KEY_HIT_SLOP)!!
+          var left = GestureHandler.HIT_SLOP_NONE
+          var top = GestureHandler.HIT_SLOP_NONE
+          var right = GestureHandler.HIT_SLOP_NONE
+          var bottom = GestureHandler.HIT_SLOP_NONE
+          var width = GestureHandler.HIT_SLOP_NONE
+          var height = GestureHandler.HIT_SLOP_NONE
+          if (hitSlop.hasKey(KEY_HIT_SLOP_HORIZONTAL)) {
+            val horizontalPad = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_HORIZONTAL))
+            right = horizontalPad
+            left = right
+          }
+          if (hitSlop.hasKey(KEY_HIT_SLOP_VERTICAL)) {
+            val verticalPad = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_VERTICAL))
+            bottom = verticalPad
+            top = bottom
+          }
+          if (hitSlop.hasKey(KEY_HIT_SLOP_LEFT)) {
+            left = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_LEFT))
+          }
+          if (hitSlop.hasKey(KEY_HIT_SLOP_TOP)) {
+            top = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_TOP))
+          }
+          if (hitSlop.hasKey(KEY_HIT_SLOP_RIGHT)) {
+            right = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_RIGHT))
+          }
+          if (hitSlop.hasKey(KEY_HIT_SLOP_BOTTOM)) {
+            bottom = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_BOTTOM))
+          }
+          if (hitSlop.hasKey(KEY_HIT_SLOP_WIDTH)) {
+            width = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_WIDTH))
+          }
+          if (hitSlop.hasKey(KEY_HIT_SLOP_HEIGHT)) {
+            height = PixelUtil.toPixelFromDIP(hitSlop.getDouble(KEY_HIT_SLOP_HEIGHT))
+          }
+          handler.setHitSlop(left, top, right, bottom, width, height)
+        }
+      }
+    }
+  }
+
   companion object {
+    private const val DEFAULT_NEEDS_POINTER_DATA = false
+    private const val DEFAULT_MANUAL_ACTIVATION = false
+    private const val DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE = false
+    private const val DEFAULT_IS_ENABLED = true
+    private val DEFAULT_HIT_SLOP = null
+    private const val DEFAULT_MOUSE_BUTTON = 0
+
     const val STATE_UNDETERMINED = 0
     const val STATE_FAILED = 1
     const val STATE_BEGAN = 2
@@ -763,26 +967,28 @@ 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?>
     private fun initPointerProps(size: Int) {
-      var size = size
+      var pointerPropsSize = size
       if (!Companion::pointerProps.isInitialized) {
         pointerProps = arrayOfNulls(MAX_POINTERS_COUNT)
         pointerCoords = arrayOfNulls(MAX_POINTERS_COUNT)
       }
-      while (size > 0 && pointerProps[size - 1] == null) {
-        pointerProps[size - 1] = PointerProperties()
-        pointerCoords[size - 1] = PointerCoords()
-        size--
+      while (pointerPropsSize > 0 && pointerProps[pointerPropsSize - 1] == null) {
+        pointerProps[pointerPropsSize - 1] = PointerProperties()
+        pointerCoords[pointerPropsSize - 1] = PointerCoords()
+        pointerPropsSize--
       }
     }
 
     private var nextEventCoalescingKey: Short = 0
-    private fun hitSlopSet(value: Float): Boolean {
-      return !java.lang.Float.isNaN(value)
-    }
+    private fun hitSlopSet(value: Float): Boolean = !java.lang.Float.isNaN(value)
 
     fun stateToString(state: Int): String? {
       when (state) {
@@ -802,6 +1008,6 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     var x: Float,
     var y: Float,
     var absoluteX: Float,
-    var absoluteY: Float
+    var absoluteY: Float,
   )
 }