react-native-gesture-handler 2.25.0 → 2.26.0

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

@@ -11,16 +11,19 @@ import android.view.MotionEvent.PointerProperties
 import android.view.View
 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 }
@@ -36,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
@@ -62,23 +75,17 @@ 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
 
   protected var mouseButton = 0
 
-  @Suppress("UNCHECKED_CAST")
-  protected fun self(): ConcreteGestureHandlerT = this as ConcreteGestureHandlerT
-
-  protected inline fun applySelf(block: ConcreteGestureHandlerT.() -> Unit): ConcreteGestureHandlerT =
-    self().apply { block() }
-
   // properties set and accessed only by the orchestrator
   var activationIndex = 0
   var isActive = false
@@ -86,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
@@ -116,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)
     }
@@ -151,25 +134,30 @@ 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" }
-  }
-
-  fun setHitSlop(padding: Float): ConcreteGestureHandlerT {
-    return setHitSlop(padding, padding, padding, padding, HIT_SLOP_NONE, HIT_SLOP_NONE)
+    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 setInteractionController(controller: GestureHandlerInteractionController?): ConcreteGestureHandlerT =
-    applySelf { interactionController = controller }
+  fun setHitSlop(padding: Float) = setHitSlop(padding, padding, padding, padding, HIT_SLOP_NONE, HIT_SLOP_NONE)
 
-  fun setMouseButton(mouseButton: Int) = apply {
-    this.mouseButton = mouseButton
+  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
@@ -189,13 +177,12 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
 
   protected open fun onPrepare() {}
 
-  private fun getActivity(context: Context?): Activity? =
-    when (context) {
-      is ReactContext -> context.currentActivity
-      is Activity -> context
-      is ContextWrapper -> getActivity(context.baseContext)
-      else -> 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 {
     var localPointerId = 0
@@ -253,7 +240,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
       }
@@ -261,7 +252,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
       }
@@ -289,7 +284,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
@@ -308,7 +305,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)
@@ -319,12 +316,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}
@@ -335,9 +329,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 ||
@@ -378,7 +372,10 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     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) {
+    if (sourceEvent.action == MotionEvent.ACTION_DOWN ||
+      sourceEvent.action == MotionEvent.ACTION_HOVER_ENTER ||
+      sourceEvent.action == MotionEvent.ACTION_HOVER_MOVE
+    ) {
       setPointerType(sourceEvent)
     }
 
@@ -473,10 +470,14 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   }
 
   fun updatePointerData(event: MotionEvent, sourceEvent: MotionEvent) {
-    if (event.actionMasked == MotionEvent.ACTION_DOWN || event.actionMasked == MotionEvent.ACTION_POINTER_DOWN) {
+    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) {
+    } 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) {
@@ -554,7 +555,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()
     }
 
@@ -570,15 +573,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 wantEvents(): Boolean = isEnabled &&
+    state != STATE_FAILED &&
+    state != STATE_CANCELLED &&
+    state != STATE_END &&
+    trackedPointersIDsCount > 0
 
-  open fun shouldRequireToWaitForFailure(handler: GestureHandler<*>): Boolean {
+  open fun shouldRequireToWaitForFailure(handler: GestureHandler): Boolean {
     if (handler === this) {
       return false
     }
@@ -586,7 +587,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
     }
@@ -594,7 +595,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
     }
@@ -602,7 +603,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
     }
@@ -657,7 +658,11 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   }
 
   fun cancel() {
-    if (state == STATE_ACTIVE || state == STATE_UNDETERMINED || state == STATE_BEGAN || this.isAwaiting) {
+    if (state == STATE_ACTIVE ||
+      state == STATE_UNDETERMINED ||
+      state == STATE_BEGAN ||
+      this.isAwaiting
+    ) {
       onCancel()
       moveToState(STATE_CANCELLED)
     }
@@ -665,6 +670,7 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
 
   fun fail() {
     if (state == STATE_ACTIVE || state == STATE_UNDETERMINED || state == STATE_BEGAN) {
+      onFail()
       moveToState(STATE_FAILED)
     }
   }
@@ -690,10 +696,10 @@ 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 {
+   * 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) {
@@ -718,6 +724,7 @@ 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) {
@@ -733,9 +740,15 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
 
     with(sourceEvent) {
       // To use actionButton, we need API >= 23.
-      if (getToolType(0) == MotionEvent.TOOL_TYPE_MOUSE && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      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) {
+        if (action == MotionEvent.ACTION_DOWN ||
+          action == MotionEvent.ACTION_UP ||
+          action == MotionEvent.ACTION_POINTER_UP ||
+          action == MotionEvent.ACTION_POINTER_DOWN
+        ) {
           return@shouldActivateWithMouse false
         }
 
@@ -750,7 +763,9 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
         }
       } 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) {
+        if (action == MotionEvent.ACTION_BUTTON_PRESS ||
+          action == MotionEvent.ACTION_BUTTON_RELEASE
+        ) {
           return@shouldActivateWithMouse false
         }
       }
@@ -767,13 +782,12 @@ 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
@@ -802,11 +816,6 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
   }
 
-  fun setOnTouchEventListener(listener: OnTouchEventListener?): GestureHandler<*> {
-    onTouchEventListener = listener
-    return this
-  }
-
   override fun toString(): String {
     val viewString = if (view == null) null else view!!.javaClass.simpleName
     return this.javaClass.simpleName + "@[" + tag + "]:" + viewString
@@ -822,7 +831,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
@@ -865,9 +982,7 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
 
     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) {
@@ -887,6 +1002,6 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     var x: Float,
     var y: Float,
     var absoluteX: Float,
-    var absoluteY: Float
+    var absoluteY: Float,
   )
 }

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

@@ -1,8 +1,8 @@
 package com.swmansion.gesturehandler.core
 
 interface GestureHandlerInteractionController {
-  fun shouldWaitForHandlerFailure(handler: GestureHandler<*>, otherHandler: GestureHandler<*>): Boolean
-  fun shouldRequireHandlerToWaitForFailure(handler: GestureHandler<*>, otherHandler: GestureHandler<*>): Boolean
-  fun shouldRecognizeSimultaneously(handler: GestureHandler<*>, otherHandler: GestureHandler<*>): Boolean
-  fun shouldHandlerBeCancelledBy(handler: GestureHandler<*>, otherHandler: GestureHandler<*>): Boolean
+  fun shouldWaitForHandlerFailure(handler: GestureHandler, otherHandler: GestureHandler): Boolean
+  fun shouldRequireHandlerToWaitForFailure(handler: GestureHandler, otherHandler: GestureHandler): Boolean
+  fun shouldRecognizeSimultaneously(handler: GestureHandler, otherHandler: GestureHandler): Boolean
+  fun shouldHandlerBeCancelledBy(handler: GestureHandler, otherHandler: GestureHandler): Boolean
 }