react-native-gesture-handler 2.25.0 → 2.27.0

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

@@ -1,11 +1,13 @@
 package com.swmansion.gesturehandler.core
 
+import android.content.Context
 import android.os.SystemClock
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewConfiguration
 import android.view.ViewGroup
 import android.widget.ScrollView
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.views.scroll.ReactHorizontalScrollView
 import com.facebook.react.views.scroll.ReactScrollView
 import com.facebook.react.views.swiperefresh.ReactSwipeRefreshLayout
@@ -13,39 +15,34 @@ import com.facebook.react.views.text.ReactTextView
 import com.facebook.react.views.textinput.ReactEditText
 import com.facebook.react.views.view.ReactViewGroup
 import com.swmansion.gesturehandler.react.RNGestureHandlerButtonViewManager
+import com.swmansion.gesturehandler.react.eventbuilders.NativeGestureHandlerEventDataBuilder
 import com.swmansion.gesturehandler.react.isScreenReaderOn
 
-class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
+class NativeViewGestureHandler : GestureHandler() {
   private var shouldActivateOnStart = false
+
+  /**
+   * Set this to `true` when wrapping native components that are supposed to be an exclusive
+   * target for a touch stream. Like for example switch or slider component which when activated
+   * aren't supposed to be cancelled by scrollview or other container that may also handle touches.
+   */
   var disallowInterruption = false
     private set
 
   private var hook: NativeViewGestureHandlerHook = defaultHook
 
   init {
-    setShouldCancelWhenOutside(true)
+    shouldCancelWhenOutside = true
   }
 
   override fun resetConfig() {
     super.resetConfig()
-    shouldActivateOnStart = false
-    disallowInterruption = false
-  }
-
-  fun setShouldActivateOnStart(shouldActivateOnStart: Boolean) = apply {
-    this.shouldActivateOnStart = shouldActivateOnStart
+    shouldActivateOnStart = DEFAULT_SHOULD_ACTIVATE_ON_START
+    disallowInterruption = DEFAULT_DISALLOW_INTERRUPTION
+    shouldCancelWhenOutside = DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE
   }
 
-  /**
-   * Set this to `true` when wrapping native components that are supposed to be an exclusive
-   * target for a touch stream. Like for example switch or slider component which when activated
-   * aren't supposed to be cancelled by scrollview or other container that may also handle touches.
-   */
-  fun setDisallowInterruption(disallowInterruption: Boolean) = apply {
-    this.disallowInterruption = disallowInterruption
-  }
-
-  override fun shouldRecognizeSimultaneously(handler: GestureHandler<*>): Boolean {
+  override fun shouldRecognizeSimultaneously(handler: GestureHandler): Boolean {
     // if the gesture is marked by user as simultaneous with other or the hook return true
     hook.shouldRecognizeSimultaneously(handler)?.let {
       return@shouldRecognizeSimultaneously it
@@ -72,13 +69,15 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
       // as it means the other handler has turned active and returning `true` would prevent it from
       // interrupting the current handler
       false
-    } else state == STATE_ACTIVE && canBeInterrupted && (!hook.shouldCancelRootViewGestureHandlerIfNecessary() || handler.tag > 0)
+    } else {
+      state == STATE_ACTIVE &&
+        canBeInterrupted &&
+        (!hook.shouldCancelRootViewGestureHandlerIfNecessary() || handler.tag > 0)
+    }
     // otherwise we can only return `true` if already in an active state
   }
 
-  override fun shouldBeCancelledBy(handler: GestureHandler<*>): Boolean {
-    return !disallowInterruption
-  }
+  override fun shouldBeCancelledBy(handler: GestureHandler): Boolean = !disallowInterruption
 
   override fun onPrepare() {
     when (val view = view) {
@@ -151,7 +150,7 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
     }
   }
 
-  override fun onCancel() {
+  private fun dispatchCancelEventToView() {
     val time = SystemClock.uptimeMillis()
     val event = MotionEvent.obtain(time, time, MotionEvent.ACTION_CANCEL, 0f, 0f, 0).apply {
       action = MotionEvent.ACTION_CANCEL
@@ -160,13 +159,44 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
     event.recycle()
   }
 
+  override fun onCancel() = dispatchCancelEventToView()
+
+  override fun onFail() = dispatchCancelEventToView()
+
   override fun onReset() {
     this.hook = defaultHook
   }
 
+  class Factory : GestureHandler.Factory<NativeViewGestureHandler>() {
+    override val type = NativeViewGestureHandler::class.java
+    override val name = "NativeViewGestureHandler"
+
+    override fun create(context: Context?): NativeViewGestureHandler = NativeViewGestureHandler()
+
+    override fun setConfig(handler: NativeViewGestureHandler, config: ReadableMap) {
+      super.setConfig(handler, config)
+      if (config.hasKey(KEY_SHOULD_ACTIVATE_ON_START)) {
+        handler.shouldActivateOnStart = config.getBoolean(KEY_SHOULD_ACTIVATE_ON_START)
+      }
+      if (config.hasKey(KEY_DISALLOW_INTERRUPTION)) {
+        handler.disallowInterruption = config.getBoolean(KEY_DISALLOW_INTERRUPTION)
+      }
+    }
+
+    override fun createEventBuilder(handler: NativeViewGestureHandler) = NativeGestureHandlerEventDataBuilder(handler)
+
+    companion object {
+      private const val KEY_SHOULD_ACTIVATE_ON_START = "shouldActivateOnStart"
+      private const val KEY_DISALLOW_INTERRUPTION = "disallowInterruption"
+    }
+  }
+
   companion object {
-    private fun tryIntercept(view: View, event: MotionEvent) =
-      view is ViewGroup && view.onInterceptTouchEvent(event)
+    private const val DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE = true
+    private const val DEFAULT_SHOULD_ACTIVATE_ON_START = false
+    private const val DEFAULT_DISALLOW_INTERRUPTION = false
+
+    private fun tryIntercept(view: View, event: MotionEvent) = view is ViewGroup && view.onInterceptTouchEvent(event)
 
     private val defaultHook = object : NativeViewGestureHandlerHook {}
   }
@@ -195,7 +225,7 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
      * @return Boolean value signalling whether the gesture can be recognized simultaneously with
      * other (handler). Returning false doesn't necessarily prevent it from happening.
      */
-    fun shouldRecognizeSimultaneously(handler: GestureHandler<*>): Boolean? = null
+    fun shouldRecognizeSimultaneously(handler: GestureHandler): Boolean? = null
 
     /**
      * shouldActivateOnStart and tryIntercept have priority over this method
@@ -222,18 +252,16 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
     fun sendTouchEvent(view: View?, event: MotionEvent) = view?.onTouchEvent(event)
   }
 
-  private class TextViewHook() : NativeViewGestureHandlerHook {
-    override fun shouldRecognizeSimultaneously(handler: GestureHandler<*>) = false
+  private class TextViewHook : NativeViewGestureHandlerHook {
+    override fun shouldRecognizeSimultaneously(handler: GestureHandler) = false
 
     // We have to explicitly check for ReactTextView, since its `isPressed` flag is not set to `true`,
     // in contrast to e.g. Touchable
     override fun canActivate(view: View) = view is ReactTextView
   }
 
-  private class EditTextHook(
-    private val handler: NativeViewGestureHandler,
-    private val editText: ReactEditText
-  ) : NativeViewGestureHandlerHook {
+  private class EditTextHook(private val handler: NativeViewGestureHandler, private val editText: ReactEditText) :
+    NativeViewGestureHandlerHook {
     private var startX = 0f
     private var startY = 0f
     private var touchSlopSquared: Int
@@ -244,7 +272,9 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
     }
 
     override fun afterGestureEnd(event: MotionEvent) {
-      if ((event.x - startX) * (event.x - startX) + (event.y - startY) * (event.y - startY) < touchSlopSquared) {
+      if (
+        (event.x - startX) * (event.x - startX) + (event.y - startY) * (event.y - startY) < touchSlopSquared
+      ) {
         editText.requestFocusFromJS()
       }
     }
@@ -252,7 +282,7 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
     // recognize alongside every handler besides RootViewGestureHandler, which is a private inner class
     // of RNGestureHandlerRootHelper so no explicit type checks, but its tag is always negative
     // also if other handler is NativeViewGestureHandler then don't override the default implementation
-    override fun shouldRecognizeSimultaneously(handler: GestureHandler<*>) =
+    override fun shouldRecognizeSimultaneously(handler: GestureHandler) =
       handler.tag > 0 && handler !is NativeViewGestureHandler
 
     override fun wantsToHandleEventBeforeActivation() = true
@@ -270,7 +300,7 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
 
   private class SwipeRefreshLayoutHook(
     private val handler: NativeViewGestureHandler,
-    private val swipeRefreshLayout: ReactSwipeRefreshLayout
+    private val swipeRefreshLayout: ReactSwipeRefreshLayout,
   ) : NativeViewGestureHandlerHook {
     override fun wantsToHandleEventBeforeActivation() = true
 

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

@@ -3,7 +3,7 @@ package com.swmansion.gesturehandler.core
 import android.view.MotionEvent
 
 interface OnTouchEventListener {
-  fun <T : GestureHandler<T>> onHandlerUpdate(handler: T, event: MotionEvent)
-  fun <T : GestureHandler<T>> onStateChange(handler: T, newState: Int, oldState: Int)
-  fun <T : GestureHandler<T>> onTouchEvent(handler: T)
+  fun <T : GestureHandler> onHandlerUpdate(handler: T, event: MotionEvent)
+  fun <T : GestureHandler> onStateChange(handler: T, newState: Int, oldState: Int)
+  fun <T : GestureHandler> onTouchEvent(handler: T)
 }

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

@@ -6,10 +6,13 @@ import android.os.Looper
 import android.view.MotionEvent
 import android.view.VelocityTracker
 import android.view.ViewConfiguration
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.PixelUtil
 import com.swmansion.gesturehandler.core.GestureUtils.getLastPointerX
 import com.swmansion.gesturehandler.core.GestureUtils.getLastPointerY
+import com.swmansion.gesturehandler.react.eventbuilders.PanGestureHandlerEventDataBuilder
 
-class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>() {
+class PanGestureHandler(context: Context?) : GestureHandler() {
   var velocityX = 0f
     private set
   var velocityY = 0f
@@ -19,8 +22,8 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
   val translationY: Float
     get() = lastY - startY + offsetY
 
-  private val defaultMinDistSq: Float
-  private var minDistSq = MAX_VALUE_IGNORE
+  private val defaultMinDist: Float
+  private var minDist = MAX_VALUE_IGNORE
   private var activeOffsetXStart = MIN_VALUE_IGNORE
   private var activeOffsetXEnd = MAX_VALUE_IGNORE
   private var failOffsetXStart = MAX_VALUE_IGNORE
@@ -29,9 +32,13 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
   private var activeOffsetYEnd = MAX_VALUE_IGNORE
   private var failOffsetYStart = MAX_VALUE_IGNORE
   private var failOffsetYEnd = MIN_VALUE_IGNORE
+
+  /**
+   * in pixels per second
+   */
   private var minVelocityX = MIN_VALUE_IGNORE
   private var minVelocityY = MIN_VALUE_IGNORE
-  private var minVelocitySq = MIN_VALUE_IGNORE
+  private var minVelocity = MIN_VALUE_IGNORE
   private var minPointers = DEFAULT_MIN_POINTERS
   private var maxPointers = DEFAULT_MAX_POINTERS
   private var startX = 0f
@@ -62,96 +69,28 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
    */
   init {
     val vc = ViewConfiguration.get(context!!)
-    val touchSlop = vc.scaledTouchSlop
-    defaultMinDistSq = (touchSlop * touchSlop).toFloat()
-    minDistSq = defaultMinDistSq
+    defaultMinDist = vc.scaledTouchSlop.toFloat()
+    minDist = defaultMinDist
   }
 
   override fun resetConfig() {
     super.resetConfig()
-    activeOffsetXStart = MIN_VALUE_IGNORE
-    activeOffsetXEnd = MAX_VALUE_IGNORE
-    failOffsetXStart = MAX_VALUE_IGNORE
-    failOffsetXEnd = MIN_VALUE_IGNORE
-    activeOffsetYStart = MIN_VALUE_IGNORE
-    activeOffsetYEnd = MAX_VALUE_IGNORE
-    failOffsetYStart = MAX_VALUE_IGNORE
-    failOffsetYEnd = MIN_VALUE_IGNORE
-    minVelocityX = MIN_VALUE_IGNORE
-    minVelocityY = MIN_VALUE_IGNORE
-    minVelocitySq = MIN_VALUE_IGNORE
-    minDistSq = defaultMinDistSq
+    activeOffsetXStart = DEFAULT_ACTIVE_OFFSET_X_START
+    activeOffsetXEnd = DEFAULT_ACTIVE_OFFSET_X_END
+    failOffsetXStart = DEFAULT_FAIL_OFFSET_X_START
+    failOffsetXEnd = DEFAULT_FAIL_OFFSET_X_END
+    activeOffsetYStart = DEFAULT_ACTIVE_OFFSET_Y_START
+    activeOffsetYEnd = DEFAULT_ACTIVE_OFFSET_Y_END
+    failOffsetYStart = DEFAULT_FAIL_OFFSET_Y_START
+    failOffsetYEnd = DEFAULT_FAIL_OFFSET_Y_END
+    minVelocityX = DEFAULT_MIN_VELOCITY_X
+    minVelocityY = DEFAULT_MIN_VELOCITY_Y
+    minVelocity = DEFAULT_MIN_VELOCITY
+    minDist = defaultMinDist
     minPointers = DEFAULT_MIN_POINTERS
     maxPointers = DEFAULT_MAX_POINTERS
     activateAfterLongPress = DEFAULT_ACTIVATE_AFTER_LONG_PRESS
-    averageTouches = false
-  }
-
-  fun setActiveOffsetXStart(activeOffsetXStart: Float) = apply {
-    this.activeOffsetXStart = activeOffsetXStart
-  }
-
-  fun setActiveOffsetXEnd(activeOffsetXEnd: Float) = apply {
-    this.activeOffsetXEnd = activeOffsetXEnd
-  }
-
-  fun setFailOffsetXStart(failOffsetXStart: Float) = apply {
-    this.failOffsetXStart = failOffsetXStart
-  }
-
-  fun setFailOffsetXEnd(failOffsetXEnd: Float) = apply {
-    this.failOffsetXEnd = failOffsetXEnd
-  }
-
-  fun setActiveOffsetYStart(activeOffsetYStart: Float) = apply {
-    this.activeOffsetYStart = activeOffsetYStart
-  }
-
-  fun setActiveOffsetYEnd(activeOffsetYEnd: Float) = apply {
-    this.activeOffsetYEnd = activeOffsetYEnd
-  }
-
-  fun setFailOffsetYStart(failOffsetYStart: Float) = apply {
-    this.failOffsetYStart = failOffsetYStart
-  }
-
-  fun setFailOffsetYEnd(failOffsetYEnd: Float) = apply {
-    this.failOffsetYEnd = failOffsetYEnd
-  }
-
-  fun setMinDist(minDist: Float) = apply {
-    minDistSq = minDist * minDist
-  }
-
-  fun setMinPointers(minPointers: Int) = apply {
-    this.minPointers = minPointers
-  }
-
-  fun setMaxPointers(maxPointers: Int) = apply {
-    this.maxPointers = maxPointers
-  }
-
-  fun setAverageTouches(averageTouches: Boolean) = apply {
-    this.averageTouches = averageTouches
-  }
-
-  fun setActivateAfterLongPress(time: Long) = apply {
-    this.activateAfterLongPress = time
-  }
-
-  /**
-   * @param minVelocity in pixels per second
-   */
-  fun setMinVelocity(minVelocity: Float) = apply {
-    minVelocitySq = minVelocity * minVelocity
-  }
-
-  fun setMinVelocityX(minVelocityX: Float) = apply {
-    this.minVelocityX = minVelocityX
-  }
-
-  fun setMinVelocityY(minVelocityY: Float) = apply {
-    this.minVelocityY = minVelocityY
+    averageTouches = DEFAULT_AVERAGE_TOUCHES
   }
 
   private fun shouldActivate(): Boolean {
@@ -170,7 +109,7 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       return true
     }
     val distSq = dx * dx + dy * dy
-    if (minDistSq != MIN_VALUE_IGNORE && distSq >= minDistSq) {
+    if (minDist != MIN_VALUE_IGNORE && distSq >= minDist * minDist) {
       return true
     }
     val vx = velocityX
@@ -186,14 +125,14 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       return true
     }
     val velocitySq = vx * vx + vy * vy
-    return minVelocitySq != MIN_VALUE_IGNORE && velocitySq >= minVelocitySq
+    return minVelocity != MIN_VALUE_IGNORE && velocitySq >= minVelocity * minVelocity
   }
 
   private fun shouldFail(): Boolean {
     val dx = lastX - startX + offsetX
     val dy = lastY - startY + offsetY
 
-    if (activateAfterLongPress > 0 && dx * dx + dy * dy > defaultMinDistSq) {
+    if (activateAfterLongPress > 0 && dx * dx + dy * dy > defaultMinDist * defaultMinDist) {
       handler?.removeCallbacksAndMessages(null)
       return true
     }
@@ -262,14 +201,19 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       } else {
         fail()
       }
-    } else if (action == MotionEvent.ACTION_POINTER_DOWN && sourceEvent.pointerCount > maxPointers) {
+    } else if (action == MotionEvent.ACTION_POINTER_DOWN &&
+      sourceEvent.pointerCount > maxPointers
+    ) {
       // When new finger is placed down (POINTER_DOWN) we check if MAX_POINTERS is not exceeded
       if (state == STATE_ACTIVE) {
         cancel()
       } else {
         fail()
       }
-    } else if (action == MotionEvent.ACTION_POINTER_UP && state == STATE_ACTIVE && sourceEvent.pointerCount < minPointers) {
+    } else if (action == MotionEvent.ACTION_POINTER_UP &&
+      state == STATE_ACTIVE &&
+      sourceEvent.pointerCount < minPointers
+    ) {
       // When finger is lifted up (POINTER_UP) and the number of pointers falls below MIN_POINTERS
       // threshold, we only want to take an action when the handler has already activated. Otherwise
       // we can still expect more fingers to be placed on screen and fulfill MIN_POINTERS criteria.
@@ -310,12 +254,163 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
     startY = lastY
   }
 
+  class Factory : GestureHandler.Factory<PanGestureHandler>() {
+    override val type = PanGestureHandler::class.java
+    override val name = "PanGestureHandler"
+
+    override fun create(context: Context?): PanGestureHandler = PanGestureHandler(context)
+
+    override fun setConfig(handler: PanGestureHandler, config: ReadableMap) {
+      super.setConfig(handler, config)
+      var hasCustomActivationCriteria = false
+      if (config.hasKey(KEY_ACTIVE_OFFSET_X_START)) {
+        handler.activeOffsetXStart =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_ACTIVE_OFFSET_X_START,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_ACTIVE_OFFSET_X_END)) {
+        handler.activeOffsetXEnd =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_ACTIVE_OFFSET_X_END,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_FAIL_OFFSET_RANGE_X_START)) {
+        handler.failOffsetXStart =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_FAIL_OFFSET_RANGE_X_START,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_FAIL_OFFSET_RANGE_X_END)) {
+        handler.failOffsetXEnd =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_FAIL_OFFSET_RANGE_X_END,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_ACTIVE_OFFSET_Y_START)) {
+        handler.activeOffsetYStart =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_ACTIVE_OFFSET_Y_START,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_ACTIVE_OFFSET_Y_END)) {
+        handler.activeOffsetYEnd =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_ACTIVE_OFFSET_Y_END,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_FAIL_OFFSET_RANGE_Y_START)) {
+        handler.failOffsetYStart =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_FAIL_OFFSET_RANGE_Y_START,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_FAIL_OFFSET_RANGE_Y_END)) {
+        handler.failOffsetYEnd =
+          PixelUtil.toPixelFromDIP(
+            config.getDouble(
+              KEY_FAIL_OFFSET_RANGE_Y_END,
+            ),
+          )
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_MIN_VELOCITY)) {
+        // This value is actually in DPs/ms, but we can use the same function as for converting
+        // from DPs to pixels as the unit we're converting is in the numerator
+        handler.minVelocity = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MIN_VELOCITY))
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_MIN_VELOCITY_X)) {
+        handler.minVelocityX = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MIN_VELOCITY_X))
+        hasCustomActivationCriteria = true
+      }
+      if (config.hasKey(KEY_MIN_VELOCITY_Y)) {
+        handler.minVelocityY = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MIN_VELOCITY_Y))
+        hasCustomActivationCriteria = true
+      }
+
+      // PanGestureHandler sets minDist by default, if there are custom criteria specified we want
+      // to reset that setting and use provided criteria instead.
+      if (config.hasKey(KEY_MIN_DIST)) {
+        handler.minDist = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MIN_DIST))
+      } else if (hasCustomActivationCriteria) {
+        handler.minDist = Float.MAX_VALUE
+      }
+      if (config.hasKey(KEY_MIN_POINTERS)) {
+        handler.minPointers = config.getInt(KEY_MIN_POINTERS)
+      }
+      if (config.hasKey(KEY_MAX_POINTERS)) {
+        handler.maxPointers = config.getInt(KEY_MAX_POINTERS)
+      }
+      if (config.hasKey(KEY_AVG_TOUCHES)) {
+        handler.averageTouches = config.getBoolean(KEY_AVG_TOUCHES)
+      }
+      if (config.hasKey(KEY_ACTIVATE_AFTER_LONG_PRESS)) {
+        handler.activateAfterLongPress = config.getInt(KEY_ACTIVATE_AFTER_LONG_PRESS).toLong()
+      }
+    }
+
+    override fun createEventBuilder(handler: PanGestureHandler) = PanGestureHandlerEventDataBuilder(handler)
+
+    companion object {
+      private const val KEY_ACTIVE_OFFSET_X_START = "activeOffsetXStart"
+      private const val KEY_ACTIVE_OFFSET_X_END = "activeOffsetXEnd"
+      private const val KEY_FAIL_OFFSET_RANGE_X_START = "failOffsetXStart"
+      private const val KEY_FAIL_OFFSET_RANGE_X_END = "failOffsetXEnd"
+      private const val KEY_ACTIVE_OFFSET_Y_START = "activeOffsetYStart"
+      private const val KEY_ACTIVE_OFFSET_Y_END = "activeOffsetYEnd"
+      private const val KEY_FAIL_OFFSET_RANGE_Y_START = "failOffsetYStart"
+      private const val KEY_FAIL_OFFSET_RANGE_Y_END = "failOffsetYEnd"
+      private const val KEY_MIN_DIST = "minDist"
+      private const val KEY_MIN_VELOCITY = "minVelocity"
+      private const val KEY_MIN_VELOCITY_X = "minVelocityX"
+      private const val KEY_MIN_VELOCITY_Y = "minVelocityY"
+      private const val KEY_MIN_POINTERS = "minPointers"
+      private const val KEY_MAX_POINTERS = "maxPointers"
+      private const val KEY_AVG_TOUCHES = "avgTouches"
+      private const val KEY_ACTIVATE_AFTER_LONG_PRESS = "activateAfterLongPress"
+    }
+  }
+
   companion object {
     private const val MIN_VALUE_IGNORE = Float.MAX_VALUE
     private const val MAX_VALUE_IGNORE = Float.MIN_VALUE
     private const val DEFAULT_MIN_POINTERS = 1
     private const val DEFAULT_MAX_POINTERS = 10
     private const val DEFAULT_ACTIVATE_AFTER_LONG_PRESS = 0L
+    private const val DEFAULT_AVERAGE_TOUCHES = false
+    private const val DEFAULT_ACTIVE_OFFSET_X_START = MIN_VALUE_IGNORE
+    private const val DEFAULT_ACTIVE_OFFSET_X_END = MAX_VALUE_IGNORE
+    private const val DEFAULT_FAIL_OFFSET_X_START = MAX_VALUE_IGNORE
+    private const val DEFAULT_FAIL_OFFSET_X_END = MIN_VALUE_IGNORE
+    private const val DEFAULT_ACTIVE_OFFSET_Y_START = MIN_VALUE_IGNORE
+    private const val DEFAULT_ACTIVE_OFFSET_Y_END = MAX_VALUE_IGNORE
+    private const val DEFAULT_FAIL_OFFSET_Y_START = MAX_VALUE_IGNORE
+    private const val DEFAULT_FAIL_OFFSET_Y_END = MIN_VALUE_IGNORE
+    private const val DEFAULT_MIN_VELOCITY_X = MIN_VALUE_IGNORE
+    private const val DEFAULT_MIN_VELOCITY_Y = MIN_VALUE_IGNORE
+    private const val DEFAULT_MIN_VELOCITY = MIN_VALUE_IGNORE
 
     /**
      * This method adds movement to {@class VelocityTracker} first resetting offset of the event so

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

@@ -1,11 +1,13 @@
 package com.swmansion.gesturehandler.core
 
+import android.content.Context
 import android.graphics.PointF
 import android.view.MotionEvent
 import android.view.ViewConfiguration
+import com.swmansion.gesturehandler.react.eventbuilders.PinchGestureHandlerEventDataBuilder
 import kotlin.math.abs
 
-class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
+class PinchGestureHandler : GestureHandler() {
   var scale = 0.0
     private set
   var velocity = 0.0
@@ -36,10 +38,6 @@ class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
       return true
     }
 
-    init {
-      setShouldCancelWhenOutside(false)
-    }
-
     override fun onScaleBegin(detector: ScaleGestureDetector): Boolean {
       startingSpan = detector.currentSpan
       return true
@@ -100,4 +98,13 @@ class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
     velocity = 0.0
     scale = 1.0
   }
+
+  class Factory : GestureHandler.Factory<PinchGestureHandler>() {
+    override val type = PinchGestureHandler::class.java
+    override val name = "PinchGestureHandler"
+
+    override fun create(context: Context?): PinchGestureHandler = PinchGestureHandler()
+
+    override fun createEventBuilder(handler: PinchGestureHandler) = PinchGestureHandlerEventDataBuilder(handler)
+  }
 }

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

@@ -19,5 +19,5 @@ enum class PointerEventsConfig {
   /**
    * Container and all of its children receive touch events (like pointerEvents is unspecified).
    */
-  AUTO
+  AUTO,
 }

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

@@ -81,7 +81,9 @@ class RotationGestureDetector(private val gestureListener: OnRotationGestureList
 
     rotation = if (previousAngle.isNaN()) {
       0.0
-    } else previousAngle - angle
+    } else {
+      previousAngle - angle
+    }
 
     previousAngle = angle
     if (rotation > Math.PI) {

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

@@ -1,11 +1,13 @@
 package com.swmansion.gesturehandler.core
 
+import android.content.Context
 import android.graphics.PointF
 import android.view.MotionEvent
 import com.swmansion.gesturehandler.core.RotationGestureDetector.OnRotationGestureListener
+import com.swmansion.gesturehandler.react.eventbuilders.RotationGestureHandlerEventDataBuilder
 import kotlin.math.abs
 
-class RotationGestureHandler : GestureHandler<RotationGestureHandler>() {
+class RotationGestureHandler : GestureHandler() {
   private var rotationGestureDetector: RotationGestureDetector? = null
   var rotation = 0.0
     private set
@@ -16,10 +18,6 @@ class RotationGestureHandler : GestureHandler<RotationGestureHandler>() {
   var anchorY: Float = Float.NaN
     private set
 
-  init {
-    setShouldCancelWhenOutside(false)
-  }
-
   private val gestureListener: OnRotationGestureListener = object : OnRotationGestureListener {
     override fun onRotation(detector: RotationGestureDetector): Boolean {
       val prevRotation: Double = rotation
@@ -87,6 +85,15 @@ class RotationGestureHandler : GestureHandler<RotationGestureHandler>() {
     rotation = 0.0
   }
 
+  class Factory : GestureHandler.Factory<RotationGestureHandler>() {
+    override val type = RotationGestureHandler::class.java
+    override val name = "RotationGestureHandler"
+
+    override fun create(context: Context?): RotationGestureHandler = RotationGestureHandler()
+
+    override fun createEventBuilder(handler: RotationGestureHandler) = RotationGestureHandlerEventDataBuilder(handler)
+  }
+
   companion object {
     private const val ROTATION_RECOGNITION_THRESHOLD = Math.PI / 36.0 // 5 deg in radians
   }