react-native-gesture-handler 2.31.0-nightly-20260202-9f573ef7b → 3.0.0-beta.2

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

@@ -15,7 +15,7 @@ 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.events.eventbuilders.NativeGestureHandlerEventDataBuilder
 import com.swmansion.gesturehandler.react.isScreenReaderOn
 
 class NativeViewGestureHandler : GestureHandler() {
@@ -167,14 +167,16 @@ class NativeViewGestureHandler : GestureHandler() {
     this.hook = defaultHook
   }
 
+  override fun wantsToAttachDirectlyToView() = true
+
   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)
+    override fun updateConfig(handler: NativeViewGestureHandler, config: ReadableMap) {
+      super.updateConfig(handler, config)
       if (config.hasKey(KEY_SHOULD_ACTIVATE_ON_START)) {
         handler.shouldActivateOnStart = config.getBoolean(KEY_SHOULD_ACTIVATE_ON_START)
       }
@@ -199,6 +201,12 @@ class NativeViewGestureHandler : GestureHandler() {
     private fun tryIntercept(view: View, event: MotionEvent) = view is ViewGroup && view.onInterceptTouchEvent(event)
 
     private val defaultHook = object : NativeViewGestureHandlerHook {}
+
+    enum class ScrollDirection(val value: Int) {
+      UP(-1),
+      DOWN(1),
+      NONE(0),
+    }
   }
 
   interface NativeViewGestureHandlerHook {
@@ -302,6 +310,7 @@ class NativeViewGestureHandler : GestureHandler() {
     private val handler: NativeViewGestureHandler,
     private val swipeRefreshLayout: ReactSwipeRefreshLayout,
   ) : NativeViewGestureHandlerHook {
+    private var lastY: Float? = null
     override fun wantsToHandleEventBeforeActivation() = true
 
     override fun handleEventBeforeActivation(event: MotionEvent) {
@@ -321,11 +330,32 @@ class NativeViewGestureHandler : GestureHandler() {
           it is NativeViewGestureHandler
         }
 
-      // If handler was found, it's active and the ScrollView is not at the top, fail the RefreshControl
-      if (scrollHandler != null && scrollHandler.state == STATE_ACTIVE && scroll.scrollY > 0) {
+      // In old API ScrollView was detecting scroll even if RefreshControl hasn't been cancelled yet.
+      // This doesn't work on new API, therefore we check scroll direction. This shouldn't affect old APIs.
+      // To determine scroll direction, we will compare current event with previous one.
+      // Note: Scrolling up is handled by `canScrollVertically` method.
+      val scrollDirection = lastY?.let {
+        val dy = it - event.y
+
+        when {
+          dy < 0 -> ScrollDirection.UP
+          dy > 0 -> ScrollDirection.DOWN
+          else -> ScrollDirection.NONE
+        }
+      } ?: ScrollDirection.NONE
+
+      // We want to fail RefreshControl if we find active ScrollView handler and we either:
+      // 1. scroll down,
+      // 2. scroll up when we are not at the top of the list.
+      if (scrollHandler != null &&
+        scrollHandler.state == STATE_ACTIVE &&
+        (scrollDirection == ScrollDirection.DOWN || scroll.canScrollVertically(ScrollDirection.UP.value))
+      ) {
         handler.fail()
       }
 
+      lastY = event.y
+
       // The drawback is that the smooth transition from scrolling to refreshing in a single swipe
       // is impossible this way and two swipes are required:
       // - one to go back to top

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

@@ -10,7 +10,7 @@ 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
+import com.swmansion.gesturehandler.react.events.eventbuilders.PanGestureHandlerEventDataBuilder
 
 class PanGestureHandler(context: Context?) : GestureHandler() {
   var velocityX = 0f
@@ -148,11 +148,25 @@ class PanGestureHandler(context: Context?) : GestureHandler() {
     return failOffsetYEnd != MIN_VALUE_IGNORE && dy > failOffsetYEnd
   }
 
+  override fun initialize(event: MotionEvent, sourceEvent: MotionEvent) {
+    resetProgress()
+    offsetX = 0f
+    offsetY = 0f
+    velocityX = 0f
+    velocityY = 0f
+    velocityTracker = VelocityTracker.obtain()
+  }
+
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     if (!shouldActivateWithMouse(sourceEvent)) {
       return
     }
 
+    if (forceReinitializeDuringOnHandle) {
+      forceReinitializeDuringOnHandle = false
+      initialize(event, sourceEvent)
+    }
+
     if (event.getToolType(0) == MotionEvent.TOOL_TYPE_STYLUS) {
       stylusData = StylusData.fromEvent(event)
     }
@@ -174,12 +188,7 @@ class PanGestureHandler(context: Context?) : GestureHandler() {
       lastY = getLastPointerY(sourceEvent, averageTouches)
     }
     if (state == STATE_UNDETERMINED && sourceEvent.pointerCount >= minPointers) {
-      resetProgress()
-      offsetX = 0f
-      offsetY = 0f
-      velocityX = 0f
-      velocityY = 0f
-      velocityTracker = VelocityTracker.obtain()
+      initialize(event, sourceEvent)
       addVelocityMovement(velocityTracker, sourceEvent)
       begin()
 
@@ -260,8 +269,8 @@ class PanGestureHandler(context: Context?) : GestureHandler() {
 
     override fun create(context: Context?): PanGestureHandler = PanGestureHandler(context)
 
-    override fun setConfig(handler: PanGestureHandler, config: ReadableMap) {
-      super.setConfig(handler, config)
+    override fun updateConfig(handler: PanGestureHandler, config: ReadableMap) {
+      super.updateConfig(handler, config)
       var hasCustomActivationCriteria = false
       if (config.hasKey(KEY_ACTIVE_OFFSET_X_START)) {
         handler.activeOffsetXStart =

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

@@ -4,7 +4,7 @@ import android.content.Context
 import android.graphics.PointF
 import android.view.MotionEvent
 import android.view.ViewConfiguration
-import com.swmansion.gesturehandler.react.eventbuilders.PinchGestureHandlerEventDataBuilder
+import com.swmansion.gesturehandler.react.events.eventbuilders.PinchGestureHandlerEventDataBuilder
 import kotlin.math.abs
 
 class PinchGestureHandler : GestureHandler() {
@@ -49,18 +49,26 @@ class PinchGestureHandler : GestureHandler() {
     }
   }
 
-  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
-    if (state == STATE_UNDETERMINED) {
-      val context = view!!.context
-      resetProgress()
-      scaleGestureDetector = ScaleGestureDetector(context, gestureListener)
-      val configuration = ViewConfiguration.get(context)
-      spanSlop = configuration.scaledTouchSlop.toFloat()
+  override fun initialize(event: MotionEvent, sourceEvent: MotionEvent) {
+    val context = view!!.context
+    resetProgress()
+    scaleGestureDetector = ScaleGestureDetector(context, gestureListener)
+    val configuration = ViewConfiguration.get(context)
+    spanSlop = configuration.scaledTouchSlop.toFloat()
 
-      // set the focal point to the position of the first pointer as NaN causes the event not to arrive
-      this.focalPointX = event.x
-      this.focalPointY = event.y
+    // set the focal point to the position of the first pointer as NaN causes the event not to arrive
+    this.focalPointX = event.x
+    this.focalPointY = event.y
+  }
 
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (forceReinitializeDuringOnHandle) {
+      forceReinitializeDuringOnHandle = false
+      initialize(event, sourceEvent)
+    }
+
+    if (state == STATE_UNDETERMINED) {
+      initialize(event, sourceEvent)
       begin()
     }
     scaleGestureDetector?.onTouchEvent(sourceEvent)

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

@@ -4,7 +4,7 @@ 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 com.swmansion.gesturehandler.react.events.eventbuilders.RotationGestureHandlerEventDataBuilder
 import kotlin.math.abs
 
 class RotationGestureHandler : GestureHandler() {
@@ -39,15 +39,23 @@ class RotationGestureHandler : GestureHandler() {
     }
   }
 
-  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
-    if (state == STATE_UNDETERMINED) {
-      resetProgress()
-      rotationGestureDetector = RotationGestureDetector(gestureListener)
+  override fun initialize(event: MotionEvent, sourceEvent: MotionEvent) {
+    resetProgress()
+    rotationGestureDetector = RotationGestureDetector(gestureListener)
 
-      // set the anchor to the position of the first pointer as NaN causes the event not to arrive
-      this.anchorX = event.x
-      this.anchorY = event.y
+    // set the anchor to the position of the first pointer as NaN causes the event not to arrive
+    this.anchorX = event.x
+    this.anchorY = event.y
+  }
 
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (forceReinitializeDuringOnHandle) {
+      forceReinitializeDuringOnHandle = false
+      initialize(event, sourceEvent)
+    }
+
+    if (state == STATE_UNDETERMINED) {
+      initialize(event, sourceEvent)
       begin()
     }
     rotationGestureDetector?.onTouchEvent(sourceEvent)

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

@@ -8,7 +8,7 @@ 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.TapGestureHandlerEventDataBuilder
+import com.swmansion.gesturehandler.react.events.eventbuilders.TapGestureHandlerEventDataBuilder
 import kotlin.math.abs
 
 class TapGestureHandler : GestureHandler() {
@@ -81,18 +81,27 @@ class TapGestureHandler : GestureHandler() {
     return maxDist != MAX_VALUE_IGNORE && dist > maxDist * maxDist
   }
 
+  override fun initialize(event: MotionEvent, sourceEvent: MotionEvent) {
+    offsetX = 0f
+    offsetY = 0f
+    startX = getLastPointerX(sourceEvent, true)
+    startY = getLastPointerY(sourceEvent, true)
+  }
+
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     if (!shouldActivateWithMouse(sourceEvent)) {
       return
     }
 
+    if (forceReinitializeDuringOnHandle) {
+      forceReinitializeDuringOnHandle = false
+      initialize(event, sourceEvent)
+    }
+
     val state = state
     val action = sourceEvent.actionMasked
     if (state == STATE_UNDETERMINED) {
-      offsetX = 0f
-      offsetY = 0f
-      startX = getLastPointerX(sourceEvent, true)
-      startY = getLastPointerY(sourceEvent, true)
+      initialize(event, sourceEvent)
     }
     if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN) {
       offsetX += lastX - startX
@@ -145,8 +154,8 @@ class TapGestureHandler : GestureHandler() {
 
     override fun create(context: Context?): TapGestureHandler = TapGestureHandler()
 
-    override fun setConfig(handler: TapGestureHandler, config: ReadableMap) {
-      super.setConfig(handler, config)
+    override fun updateConfig(handler: TapGestureHandler, config: ReadableMap) {
+      super.updateConfig(handler, config)
       if (config.hasKey(KEY_NUMBER_OF_TAPS)) {
         handler.numberOfTaps = config.getInt(KEY_NUMBER_OF_TAPS)
       }

package/android/src/main/java/com/swmansion/gesturehandler/react/Extensions.kt

@@ -5,14 +5,10 @@ import android.view.MotionEvent
 import android.view.accessibility.AccessibilityManager
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.facebook.react.uimanager.UIManagerModule
 
 val ReactContext.deviceEventEmitter: DeviceEventManagerModule.RCTDeviceEventEmitter
   get() = this.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
 
-val ReactContext.UIManager: UIManagerModule
-  get() = this.getNativeModule(UIManagerModule::class.java)!!
-
 fun Context.isScreenReaderOn() =
   (getSystemService(Context.ACCESSIBILITY_SERVICE) as AccessibilityManager).isTouchExplorationEnabled
 

package/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerButtonViewManager.kt

@@ -21,7 +21,6 @@ import android.view.MotionEvent
 import android.view.View
 import android.view.View.OnClickListener
 import android.view.ViewGroup
-import android.view.ViewParent
 import android.view.accessibility.AccessibilityNodeInfo
 import androidx.core.view.children
 import com.facebook.react.R
@@ -513,9 +512,9 @@ class RNGestureHandlerButtonViewManager :
       // a parent button from playing)
       return if (!isChildTouched()) {
         if (context.isScreenReaderOn()) {
-          findGestureHandlerRootView()?.activateNativeHandlers(this)
+          RNGestureHandlerRootView.findGestureHandlerRootView(this)?.activateNativeHandlers(this)
         } else if (receivedKeyEvent) {
-          findGestureHandlerRootView()?.activateNativeHandlers(this)
+          RNGestureHandlerRootView.findGestureHandlerRootView(this)?.activateNativeHandlers(this)
           receivedKeyEvent = false
         }
 
@@ -554,20 +553,6 @@ class RNGestureHandlerButtonViewManager :
       // by default Viewgroup would pass hotspot change events
     }
 
-    private fun findGestureHandlerRootView(): RNGestureHandlerRootView? {
-      var parent: ViewParent? = this.parent
-      var gestureHandlerRootView: RNGestureHandlerRootView? = null
-
-      while (parent != null) {
-        if (parent is RNGestureHandlerRootView) {
-          gestureHandlerRootView = parent
-        }
-        parent = parent.parent
-      }
-
-      return gestureHandlerRootView
-    }
-
     companion object {
       var resolveOutValue = TypedValue()
       var touchResponder: ButtonViewGroup? = null

package/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerButtonWrapperViewManager.kt

@@ -0,0 +1,30 @@
+package com.swmansion.gesturehandler.react
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.RNGestureHandlerButtonWrapperManagerDelegate
+import com.facebook.react.viewmanagers.RNGestureHandlerButtonWrapperManagerInterface
+import com.facebook.react.views.view.ReactViewGroup
+
+@ReactModule(name = RNGestureHandlerButtonWrapperViewManager.REACT_CLASS)
+class RNGestureHandlerButtonWrapperViewManager :
+  ViewGroupManager<ReactViewGroup>(),
+  RNGestureHandlerButtonWrapperManagerInterface<ReactViewGroup> {
+  private val mDelegate: ViewManagerDelegate<ReactViewGroup> =
+    RNGestureHandlerButtonWrapperManagerDelegate<
+      ReactViewGroup,
+      RNGestureHandlerButtonWrapperViewManager,
+      >(this)
+
+  override fun getDelegate(): ViewManagerDelegate<ReactViewGroup> = mDelegate
+
+  override fun getName() = REACT_CLASS
+
+  override fun createViewInstance(reactContext: ThemedReactContext) = ReactViewGroup(reactContext)
+
+  companion object {
+    const val REACT_CLASS = "RNGestureHandlerButtonWrapper"
+  }
+}

package/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerDetectorView.kt

@@ -0,0 +1,273 @@
+package com.swmansion.gesturehandler.react
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.view.isNotEmpty
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.views.swiperefresh.ReactSwipeRefreshLayout
+import com.facebook.react.views.view.ReactViewGroup
+import com.swmansion.gesturehandler.core.GestureHandler
+import com.swmansion.gesturehandler.react.RNGestureHandlerRootView
+
+class RNGestureHandlerDetectorView(context: Context) : ReactViewGroup(context) {
+  private val reactContext: ThemedReactContext
+    get() = context as ThemedReactContext
+  private var handlersToAttach: List<Int>? = null
+  private var virtualChildrenToAttach: List<VirtualChildren>? = null
+  private var nativeHandlers: MutableSet<Int> = mutableSetOf()
+  private var attachedHandlers: MutableSet<Int> = mutableSetOf()
+  private var attachedVirtualHandlers: MutableMap<Int, MutableSet<Int>> = mutableMapOf()
+  private var moduleId: Int = -1
+
+  data class VirtualChildren(val handlerTags: List<Int>, val viewTag: Int)
+
+  fun setHandlerTags(handlerTags: ReadableArray?) {
+    val newHandlers = handlerTags?.toArrayList()?.map { (it as Double).toInt() } ?: emptyList()
+    if (moduleId == -1) {
+      // It's possible that handlerTags will be set before module id. In that case, store
+      // the handler ids and attach them after setting module id.
+      handlersToAttach = newHandlers
+      return
+    }
+
+    attachHandlers(newHandlers)
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+
+    if (moduleId != -1) {
+      handlersToAttach?.let {
+        attachHandlers(it)
+      }
+
+      virtualChildrenToAttach?.let {
+        attachVirtualChildren(it)
+      }
+
+      handlersToAttach = null
+      virtualChildrenToAttach = null
+    }
+  }
+
+  override fun onDetachedFromWindow() {
+    if (attachedHandlers.isNotEmpty()) {
+      handlersToAttach = attachedHandlers.toMutableList().also {
+        it.addAll(handlersToAttach ?: emptyList())
+      }
+    }
+
+    if (attachedVirtualHandlers.isNotEmpty()) {
+      virtualChildrenToAttach = attachedVirtualHandlers.map {
+        VirtualChildren(it.value.toList(), it.key)
+      }.toMutableList().also {
+        it.addAll(virtualChildrenToAttach ?: emptyList())
+      }
+    }
+
+    detachAllHandlers()
+
+    super.onDetachedFromWindow()
+  }
+
+  fun setModuleId(id: Int) {
+    assert(this.moduleId == -1) { "Tried to change moduleId of a native detector" }
+
+    this.moduleId = id
+    this.attachHandlers(handlersToAttach ?: return)
+    handlersToAttach = null
+    this.attachVirtualChildren(virtualChildrenToAttach ?: return)
+    virtualChildrenToAttach = null
+  }
+
+  fun setVirtualChildren(newVirtualChildren: ReadableArray?) {
+    val mappedChildren = newVirtualChildren?.mapVirtualChildren().orEmpty()
+
+    if (moduleId == -1) {
+      // It's possible that handlerTags will be set before module id. In that case, store
+      // the handler ids and attach them after setting module id.
+      virtualChildrenToAttach = mappedChildren
+      return
+    }
+
+    attachVirtualChildren(mappedChildren)
+  }
+
+  private fun shouldAttachGestureToChildView(tag: Int): Boolean {
+    val registry = RNGestureHandlerModule.registries[moduleId]
+      ?: throw Exception("Tried to access a non-existent registry")
+
+    return registry.getHandler(tag)?.wantsToAttachDirectlyToView() ?: false
+  }
+
+  // We override this `addView` because it is called inside `addView(child: View?, index: Int)`
+  override fun addView(child: View, index: Int, params: LayoutParams?) {
+    super.addView(child, index, params)
+
+    tryAttachNativeHandlersToChildView(child)
+  }
+
+  override fun removeViewAt(index: Int) {
+    detachNativeGestureHandlers()
+
+    super.removeViewAt(index)
+  }
+
+  private fun attachHandlers(
+    newHandlers: List<Int>,
+    viewTag: Int = this.id,
+    actionType: Int = GestureHandler.ACTION_TYPE_NATIVE_DETECTOR,
+    attachedHandlers: MutableSet<Int> = this.attachedHandlers,
+  ) {
+    val registry = RNGestureHandlerModule.registries[moduleId]
+      ?: throw Exception("Tried to access a non-existent registry")
+
+    val handlersToDetach = attachedHandlers.toMutableSet()
+
+    for (tag in newHandlers) {
+      handlersToDetach.remove(tag)
+      if (!attachedHandlers.contains(tag)) {
+        if (shouldAttachGestureToChildView(tag) && actionType == GestureHandler.ACTION_TYPE_NATIVE_DETECTOR) {
+          // It might happen that `attachHandlers` will be called before children are added into view hierarchy. In that case we cannot
+          // attach `NativeViewGestureHandlers` here and we have to do it in `addView` method.
+          nativeHandlers.add(tag)
+        } else {
+          registry.attachHandlerToView(tag, viewTag, actionType, this)
+          if (actionType == GestureHandler.ACTION_TYPE_VIRTUAL_DETECTOR) {
+            registry.getHandler(tag)?.hostDetectorView = this
+          }
+          attachedHandlers.add(tag)
+        }
+      }
+    }
+
+    for (tag in handlersToDetach) {
+      registry.detachHandlerFromHostDetector(tag, this)
+      nativeHandlers.remove(tag)
+      attachedHandlers.remove(tag)
+    }
+
+    val child = getChildAt(0)
+
+    // This covers the case where `NativeViewGestureHandlers` are attached after child views were created.
+    if (child != null) {
+      tryAttachNativeHandlersToChildView(child)
+    }
+  }
+
+  private fun attachVirtualChildren(virtualChildrenToAttach: List<VirtualChildren>) {
+    val virtualChildrenToDetach = attachedVirtualHandlers.keys.toMutableSet()
+
+    for (child in virtualChildrenToAttach) {
+      virtualChildrenToDetach.remove(child.viewTag)
+    }
+
+    val registry = RNGestureHandlerModule.registries[moduleId]
+      ?: throw Exception("Tried to access a non-existent registry")
+
+    for (child in virtualChildrenToDetach) {
+      for (tag in attachedVirtualHandlers[child]!!) {
+        registry.detachHandlerFromHostDetector(tag, this)
+      }
+      attachedVirtualHandlers.remove(tag)
+    }
+
+    for (child in virtualChildrenToAttach) {
+      if (!attachedVirtualHandlers.containsKey(child.viewTag)) {
+        attachedVirtualHandlers[child.viewTag] = mutableSetOf()
+      }
+
+      attachHandlers(
+        child.handlerTags,
+        child.viewTag,
+        GestureHandler.ACTION_TYPE_VIRTUAL_DETECTOR,
+        attachedVirtualHandlers[child.viewTag]!!,
+      )
+    }
+  }
+
+  private fun tryAttachNativeHandlersToChildView(child: View) {
+    val registry = RNGestureHandlerModule.registries[moduleId]
+      ?: throw Exception("Tried to access a non-existent registry")
+
+    // In the native view hierarchy, a ScrollView is a child of a RefreshControl.
+    // When attaching Native gestures to a ScrollView, first check if it is wrapped by a RefreshControl.
+    // If so, attach the handler to the child of RefreshControl, not the RefreshControl itself.
+    // Note: RefreshControl is wrapped with a VirtualDetector, and native gestures for it are attached in `attachVirtualChildren`.
+    val id = if (child is ReactSwipeRefreshLayout) {
+      child.getChildAt(0).id
+      // TODO: figure out how to do it correctly
+    } else if (child is ViewGroup && child.isNotEmpty()) {
+      child.tryFindGestureHandlerButton()?.id ?: child.id
+    } else {
+      child.id
+    }
+
+    for (tag in nativeHandlers) {
+      registry.attachHandlerToView(tag, id, GestureHandler.ACTION_TYPE_NATIVE_DETECTOR, this)
+
+      attachedHandlers.add(tag)
+    }
+  }
+
+  private fun detachNativeGestureHandlers() {
+    val registry = RNGestureHandlerModule.registries[moduleId]
+      ?: throw Exception("Tried to access a non-existent registry")
+
+    for (tag in nativeHandlers) {
+      registry.detachHandlerFromHostDetector(tag, this)
+      attachedHandlers.remove(tag)
+    }
+  }
+
+  fun dispatchEvent(event: Event<*>) {
+    val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+    eventDispatcher?.dispatchEvent(event)
+  }
+
+  fun detachAllHandlers() {
+    val registry = RNGestureHandlerModule.registries[moduleId]
+      ?: throw Exception("Tried to access a non-existent registry")
+
+    for (tag in attachedHandlers.toMutableSet()) {
+      registry.detachHandlerFromHostDetector(tag, this)
+      attachedHandlers.remove(tag)
+    }
+
+    for (child in attachedVirtualHandlers) {
+      for (tag in child.value) {
+        registry.detachHandlerFromHostDetector(tag, this)
+      }
+      child.value.clear()
+    }
+  }
+
+  fun recordHandlerIfNotPresent(handler: GestureHandler) {
+    RNGestureHandlerRootView.findGestureHandlerRootView(this)?.recordHandlerIfNotPresent(handler)
+  }
+
+  private fun ReadableArray.mapVirtualChildren(): List<VirtualChildren> = List(size()) { i ->
+    val child = getMap(i) ?: return@List null
+    val handlerTags = child.getArray("handlerTags")?.toIntList().orEmpty()
+    val viewTag = child.getInt("viewTag")
+
+    VirtualChildren(handlerTags, viewTag)
+  }.filterNotNull()
+
+  private fun ReadableArray.toIntList(): List<Int> = List(size()) { getInt(it) }
+
+  private fun ViewGroup.tryFindGestureHandlerButton(): RNGestureHandlerButtonViewManager.ButtonViewGroup? {
+    if (isNotEmpty()) {
+      val child = getChildAt(0)
+      if (child is RNGestureHandlerButtonViewManager.ButtonViewGroup) {
+        return child
+      }
+    }
+
+    return null
+  }
+}