@amazon-devices/react-native-gesture-handler 2.0.1758683737 → 4.0.0

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

@@ -1,17 +1,22 @@
 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>() {
+class HoverGestureHandler : GestureHandler() {
   private var handler: Handler? = null
   private var finishRunnable = Runnable { finish() }
+  var stylusData: StylusData = StylusData()
+    private set
 
-  private infix fun isAncestorOf(other: GestureHandler<*>): Boolean {
+  private infix fun isAncestorOf(other: GestureHandler): Boolean {
     var current: View? = other.view
 
     while (current != null) {
@@ -45,7 +50,7 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
     return null
   }
 
-  override fun shouldBeCancelledBy(handler: GestureHandler<*>): Boolean {
+  override fun shouldBeCancelledBy(handler: GestureHandler): Boolean {
     if (handler is HoverGestureHandler && !(handler isAncestorOf this)) {
       return isViewDisplayedOverAnother(handler.view!!, this.view!!)!!
     }
@@ -53,7 +58,7 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
     return super.shouldBeCancelledBy(handler)
   }
 
-  override fun shouldRequireToWaitForFailure(handler: GestureHandler<*>): Boolean {
+  override fun shouldRequireToWaitForFailure(handler: GestureHandler): Boolean {
     if (handler is HoverGestureHandler) {
       if (!(this isAncestorOf handler) && !(handler isAncestorOf this)) {
         isViewDisplayedOverAnother(this.view!!, handler.view!!)?.let {
@@ -65,11 +70,15 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
     return super.shouldRequireToWaitForFailure(handler)
   }
 
-  override fun shouldRecognizeSimultaneously(handler: GestureHandler<*>): Boolean {
+  override fun shouldRecognizeSimultaneously(handler: GestureHandler): Boolean {
     if (handler is HoverGestureHandler && (this isAncestorOf handler || handler isAncestorOf this)) {
       return true
     }
 
+    if (handler is RNGestureHandlerRootHelper.RootViewGestureHandler) {
+      return true
+    }
+
     return super.shouldRecognizeSimultaneously(handler)
   }
 
@@ -98,14 +107,26 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
         finish()
       }
 
+      this.state == STATE_ACTIVE && event.getToolType(0) == MotionEvent.TOOL_TYPE_STYLUS -> {
+        stylusData = StylusData.fromEvent(event)
+      }
+
       this.state == STATE_UNDETERMINED &&
-        (event.action == MotionEvent.ACTION_HOVER_MOVE || event.action == MotionEvent.ACTION_HOVER_ENTER) -> {
+        (
+          event.action == MotionEvent.ACTION_HOVER_MOVE ||
+            event.action == MotionEvent.ACTION_HOVER_ENTER
+          ) -> {
         begin()
         activate()
       }
     }
   }
 
+  override fun onReset() {
+    super.onReset()
+    stylusData = StylusData()
+  }
+
   private fun finish() {
     when (this.state) {
       STATE_UNDETERMINED -> cancel()
@@ -114,6 +135,15 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
     }
   }
 
+  class Factory : GestureHandler.Factory<HoverGestureHandler>() {
+    override val type = HoverGestureHandler::class.java
+    override val name = "HoverGestureHandler"
+
+    override fun create(context: Context?): HoverGestureHandler = HoverGestureHandler()
+
+    override fun createEventBuilder(handler: HoverGestureHandler) = HoverGestureHandlerEventDataBuilder(handler)
+  }
+
   companion object {
     private val viewConfigHelper = RNViewConfigurationHelper()
   }

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

@@ -5,45 +5,103 @@ import android.os.Handler
 import android.os.Looper
 import android.os.SystemClock
 import android.view.MotionEvent
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.react.eventbuilders.LongPressGestureHandlerEventDataBuilder
 
-class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestureHandler>() {
+class LongPressGestureHandler(context: Context) : GestureHandler() {
   var minDurationMs = DEFAULT_MIN_DURATION_MS
   val duration: Int
     get() = (previousTime - startTime).toInt()
-  private val defaultMaxDistSq: Float
-  private var maxDistSq: Float
+  private val defaultMaxDist: Float
+  private var maxDist: Float
+  private var numberOfPointersRequired: Int
   private var startX = 0f
   private var startY = 0f
   private var startTime: Long = 0
   private var previousTime: Long = 0
   private var handler: Handler? = null
+  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
+    maxDist = defaultMaxDist
+    shouldCancelWhenOutside = DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE
   }
 
-  fun setMaxDist(maxDist: Float): LongPressGestureHandler {
-    maxDistSq = maxDist * maxDist
-    return this
+  private fun getAverageCoords(ev: MotionEvent, excludePointer: Boolean = false): Pair<Float, Float> {
+    if (!excludePointer) {
+      val x = (0 until ev.pointerCount).map { ev.getX(it) }.average().toFloat()
+      val y = (0 until ev.pointerCount).map { ev.getY(it) }.average().toFloat()
+
+      return Pair(x, y)
+    }
+
+    var sumX = 0f
+    var sumY = 0f
+
+    for (i in 0 until ev.pointerCount) {
+      if (i == ev.actionIndex) {
+        continue
+      }
+
+      sumX += ev.getX(i)
+      sumY += ev.getY(i)
+    }
+
+    val x = sumX / (ev.pointerCount - 1)
+    val y = sumY / (ev.pointerCount - 1)
+
+    return Pair(x, y)
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (!shouldActivateWithMouse(sourceEvent)) {
+      return
+    }
+
     if (state == STATE_UNDETERMINED) {
       previousTime = SystemClock.uptimeMillis()
       startTime = previousTime
       begin()
-      startX = sourceEvent.rawX
-      startY = sourceEvent.rawY
+
+      val (x, y) = getAverageCoords(sourceEvent)
+      startX = x
+      startY = y
+
+      currentPointers++
+    }
+
+    if (sourceEvent.actionMasked == MotionEvent.ACTION_POINTER_DOWN) {
+      currentPointers++
+
+      val (x, y) = getAverageCoords(sourceEvent)
+      startX = x
+      startY = y
+
+      if (currentPointers > numberOfPointersRequired) {
+        fail()
+        currentPointers = 0
+      }
+    }
+
+    if (state == STATE_BEGAN &&
+      currentPointers == numberOfPointersRequired &&
+      (
+        sourceEvent.actionMasked == MotionEvent.ACTION_DOWN ||
+          sourceEvent.actionMasked == MotionEvent.ACTION_POINTER_DOWN
+        )
+    ) {
       handler = Handler(Looper.getMainLooper())
       if (minDurationMs > 0) {
         handler!!.postDelayed({ activate() }, minDurationMs)
@@ -51,7 +109,11 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
         activate()
       }
     }
-    if (sourceEvent.actionMasked == MotionEvent.ACTION_UP) {
+    if (sourceEvent.actionMasked == MotionEvent.ACTION_UP ||
+      sourceEvent.actionMasked == MotionEvent.ACTION_BUTTON_RELEASE
+    ) {
+      currentPointers--
+
       handler?.let {
         it.removeCallbacksAndMessages(null)
         handler = null
@@ -61,12 +123,26 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
       } else {
         fail()
       }
+    } else if (sourceEvent.actionMasked == MotionEvent.ACTION_POINTER_UP) {
+      currentPointers--
+
+      if (currentPointers < numberOfPointersRequired && state != STATE_ACTIVE) {
+        fail()
+        currentPointers = 0
+      } else {
+        val (x, y) = getAverageCoords(sourceEvent, true)
+        startX = x
+        startY = y
+      }
     } else {
       // calculate distance from start
-      val deltaX = sourceEvent.rawX - startX
-      val deltaY = sourceEvent.rawY - startY
+      val (x, y) = getAverageCoords(sourceEvent)
+
+      val deltaX = x - startX
+      val deltaY = y - startY
       val distSq = deltaX * deltaX + deltaY * deltaY
-      if (distSq > maxDistSq) {
+
+      if (distSq > maxDist * maxDist) {
         if (state == STATE_ACTIVE) {
           cancel()
         } else {
@@ -93,7 +169,41 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
     super.dispatchHandlerUpdate(event)
   }
 
+  override fun onReset() {
+    super.onReset()
+    currentPointers = 0
+  }
+
+  class Factory : GestureHandler.Factory<LongPressGestureHandler>() {
+    override val type = LongPressGestureHandler::class.java
+    override val name = "LongPressGestureHandler"
+
+    override fun create(context: Context?): LongPressGestureHandler = LongPressGestureHandler((context)!!)
+
+    override fun setConfig(handler: LongPressGestureHandler, config: ReadableMap) {
+      super.setConfig(handler, config)
+      if (config.hasKey(KEY_MIN_DURATION_MS)) {
+        handler.minDurationMs = config.getInt(KEY_MIN_DURATION_MS).toLong()
+      }
+      if (config.hasKey(KEY_MAX_DIST)) {
+        handler.maxDist = PixelUtil.toPixelFromDIP(config.getDouble(KEY_MAX_DIST))
+      }
+      if (config.hasKey(KEY_NUMBER_OF_POINTERS)) {
+        handler.numberOfPointers = config.getInt(KEY_NUMBER_OF_POINTERS)
+      }
+    }
+
+    override fun createEventBuilder(handler: LongPressGestureHandler) = LongPressGestureHandlerEventDataBuilder(handler)
+
+    companion object {
+      private const val KEY_MIN_DURATION_MS = "minDurationMs"
+      private const val KEY_MAX_DIST = "maxDist"
+      private const val KEY_NUMBER_OF_POINTERS = "numberOfPointers"
+    }
+  }
+
   companion object {
+    private const val DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE = true
     private const val DEFAULT_MIN_DURATION_MS: Long = 500
     private const val DEFAULT_MAX_DIST_DP = 10f
   }

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

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

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

@@ -1,48 +1,54 @@
 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
+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
-  }
-
-  /**
-   * 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
+    shouldActivateOnStart = DEFAULT_SHOULD_ACTIVATE_ON_START
+    disallowInterruption = DEFAULT_DISALLOW_INTERRUPTION
+    shouldCancelWhenOutside = DEFAULT_SHOULD_CANCEL_WHEN_OUTSIDE
   }
 
-  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
-    if (super.shouldRecognizeSimultaneously(handler) || hook.shouldRecognizeSimultaneously(handler)) {
+    hook.shouldRecognizeSimultaneously(handler)?.let {
+      return@shouldRecognizeSimultaneously it
+    }
+
+    if (super.shouldRecognizeSimultaneously(handler)) {
       return true
     }
 
@@ -63,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) {
@@ -77,61 +85,118 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
       is ReactEditText -> this.hook = EditTextHook(this, view)
       is ReactSwipeRefreshLayout -> this.hook = SwipeRefreshLayoutHook(this, view)
       is ReactScrollView -> this.hook = ScrollViewHook()
+      is ReactHorizontalScrollView -> this.hook = ScrollViewHook()
+      is ReactTextView -> this.hook = TextViewHook()
+      is ReactViewGroup -> this.hook = ReactViewGroupHook()
     }
   }
 
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     val view = view!!
+
+    val isTouchExplorationEnabled = view.context.isScreenReaderOn()
+
+    if (view is RNGestureHandlerButtonViewManager.ButtonViewGroup && isTouchExplorationEnabled) {
+      // Fix for: https://github.com/software-mansion/react-native-gesture-handler/issues/2808
+      // When TalkBack is enabled, events are often not being sent to the orchestrator for processing.
+      // Instead, states will be changed directly by an alternative mechanism added in this PR:
+      // https://github.com/software-mansion/react-native-gesture-handler/pull/2234
+      return
+    }
+
     if (event.actionMasked == MotionEvent.ACTION_UP) {
-      view.onTouchEvent(event)
-      if ((state == STATE_UNDETERMINED || state == STATE_BEGAN) && view.isPressed) {
-        activate()
+      if (state == STATE_UNDETERMINED && !hook.canBegin(event)) {
+        cancel()
+      } else {
+        hook.sendTouchEvent(view, event)
+
+        if ((state == STATE_UNDETERMINED || state == STATE_BEGAN) && hook.canActivate(view)) {
+          activate()
+        }
+
+        if (state == STATE_UNDETERMINED) {
+          cancel()
+        } else {
+          end()
+        }
       }
-      end()
+
       hook.afterGestureEnd(event)
     } else if (state == STATE_UNDETERMINED || state == STATE_BEGAN) {
       when {
         shouldActivateOnStart -> {
           tryIntercept(view, event)
-          view.onTouchEvent(event)
+          hook.sendTouchEvent(view, event)
           activate()
         }
+
         tryIntercept(view, event) -> {
-          view.onTouchEvent(event)
+          hook.sendTouchEvent(view, event)
           activate()
         }
+
         hook.wantsToHandleEventBeforeActivation() -> {
           hook.handleEventBeforeActivation(event)
         }
+
         state != STATE_BEGAN -> {
-          if (hook.canBegin()) {
+          if (hook.canBegin(event)) {
             begin()
-          } else {
-            cancel()
           }
         }
       }
     } else if (state == STATE_ACTIVE) {
-      view.onTouchEvent(event)
+      hook.sendTouchEvent(view, event)
     }
   }
 
-  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
     }
-    view!!.onTouchEvent(event)
+    hook.sendTouchEvent(view, event)
     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 {}
   }
@@ -144,7 +209,12 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
      * @return Boolean value signalling whether the handler can transition to the BEGAN state. If false
      * the gesture will be cancelled.
      */
-    fun canBegin() = true
+    fun canBegin(event: MotionEvent) = true
+
+    /**
+     * Checks whether handler can activate. Used by TextViewHook.
+     */
+    fun canActivate(view: View) = view.isPressed
 
     /**
      * Called after the gesture transitions to the END state.
@@ -155,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<*>) = false
+    fun shouldRecognizeSimultaneously(handler: GestureHandler): Boolean? = null
 
     /**
      * shouldActivateOnStart and tryIntercept have priority over this method
@@ -175,12 +245,23 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
      * by this one.
      */
     fun shouldCancelRootViewGestureHandlerIfNecessary() = false
+
+    /**
+     * Passes the event down to the underlying view using the correct method.
+     */
+    fun sendTouchEvent(view: View?, event: MotionEvent) = view?.onTouchEvent(event)
   }
 
-  private class EditTextHook(
-    private val handler: NativeViewGestureHandler,
-    private val editText: ReactEditText
-  ) : NativeViewGestureHandlerHook {
+  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 var startX = 0f
     private var startY = 0f
     private var touchSlopSquared: Int
@@ -191,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()
       }
     }
@@ -199,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
@@ -217,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
 
@@ -254,4 +337,12 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
   private class ScrollViewHook : NativeViewGestureHandlerHook {
     override fun shouldCancelRootViewGestureHandlerIfNecessary() = true
   }
+
+  private class ReactViewGroupHook : NativeViewGestureHandlerHook {
+    // There are cases where a native component is wrapped with a `ReactViewGroup` (the component is rendered
+    // inside a `<View />` component in JS). In such cases, calling `onTouchEvent` wouldn't work as those are
+    // ignored by the wrapper view. Instead `dispatchTouchEvent` can be used, which causes the view to dispatch
+    // the event to its children.
+    override fun sendTouchEvent(view: View?, event: MotionEvent) = view?.dispatchTouchEvent(event)
+  }
 }

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)
 }