Update how handler configuration is handled on Android (#3484)

## Description

All handler factories were stored in the `RNGestureHandlerModule` which
always seemed like an odd place to keep them in to me. This PR moves
each factory to be a nested class of the relevant gesture handler. This
gives us private access to the handler inside the factory, which in turn
allows to get rid of the setter methods and assign directly instead.
Those were with use since RNGH was written in java, but we have Kotlin
now. It's time to let go and use proper syntax.

It also adds default constants for each config property that didn't have
it before.

## Test plan

Example app

Author: j-piasecki

android/src/main/java/com/swmansion/gesturehandler/core/FlingGestureHandler.kt

@@ -1,9 +1,12 @@
 package com.swmansion.gesturehandler.core
 
+import android.content.Context
 import android.os.Handler
 import android.os.Looper
 import android.view.MotionEvent
 import android.view.VelocityTracker
+import com.facebook.react.bridge.ReadableMap
+import com.swmansion.gesturehandler.react.eventbuilders.FlingGestureHandlerEventDataBuilder
 
 class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
   var numberOfPointersRequired = DEFAULT_NUMBER_OF_TOUCHES_REQUIRED
@@ -126,6 +129,32 @@ class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
     event.offsetLocation(-offsetX, -offsetY)
   }
 
+  class Factory : GestureHandler.Factory<FlingGestureHandler>() {
+    override val type = FlingGestureHandler::class.java
+    override val name = "FlingGestureHandler"
+
+    override fun create(context: Context?): FlingGestureHandler {
+      return FlingGestureHandler()
+    }
+
+    override fun setConfig(handler: FlingGestureHandler, config: ReadableMap) {
+      super.setConfig(handler, config)
+      if (config.hasKey(KEY_NUMBER_OF_POINTERS)) {
+        handler.numberOfPointersRequired = config.getInt(KEY_NUMBER_OF_POINTERS)
+      }
+      if (config.hasKey(KEY_DIRECTION)) {
+        handler.direction = config.getInt(KEY_DIRECTION)
+      }
+    }
+
+    override fun createEventBuilder(handler: FlingGestureHandler) = FlingGestureHandlerEventDataBuilder(handler)
+
+    companion object {
+      private const val KEY_NUMBER_OF_POINTERS = "numberOfPointers"
+      private const val KEY_DIRECTION = "direction"
+    }
+  }
+
   companion object {
     private const val DEFAULT_MAX_DURATION_MS: Long = 800
     private const val DEFAULT_MIN_VELOCITY: Long = 2000

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

@@ -11,12 +11,15 @@ 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.*
 
@@ -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,9 +75,9 @@ 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
   private var interactionController: GestureHandlerInteractionController? = null
@@ -100,11 +113,12 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   }
 
   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 {
@@ -116,24 +130,6 @@ 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,
@@ -164,10 +160,6 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   fun setInteractionController(controller: GestureHandlerInteractionController?): ConcreteGestureHandlerT =
     applySelf { interactionController = controller }
 
-  fun setMouseButton(mouseButton: Int) = apply {
-    this.mouseButton = mouseButton
-  }
-
   fun prepare(view: View?, orchestrator: GestureHandlerOrchestrator?) {
     check(!(this.view != null || this.orchestrator != null)) { "Already prepared or hasn't been reset" }
     Arrays.fill(trackedPointerIDs, -1)
@@ -822,7 +814,104 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
   val lastPositionInWindowY: Float
     get() = lastAbsolutePositionY + lastEventOffsetY - windowOffset[1]
 
+  abstract class Factory<T : GestureHandler<T>> {
+    abstract val type: Class<T>
+    abstract val name: String
+    abstract fun create(context: Context?): T
+    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

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

@@ -1,12 +1,14 @@
 package com.swmansion.gesturehandler.core
 
+import android.content.Context
 import android.os.Handler
 import android.os.Looper
 import android.view.MotionEvent
 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>() {
   private var handler: Handler? = null
@@ -130,6 +132,17 @@ 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 {
+      return HoverGestureHandler()
+    }
+
+    override fun createEventBuilder(handler: HoverGestureHandler) = HoverGestureHandlerEventDataBuilder(handler)
+  }
+
   companion object {
     private val viewConfigHelper = RNViewConfigurationHelper()
   }

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>() {
   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> {
@@ -141,7 +135,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 +167,38 @@ 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 {
+      return 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
   }