react-native-gesture-handler 2.12.1 → 2.13.0

package/RNGestureHandler.podspec

@@ -2,21 +2,6 @@ require "json"
 
 fabric_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
 
-isUserApp = File.exist?(File.join(__dir__, "..", "..", "node_modules", "react-native", "package.json"))
-if isUserApp
-  libInstances = %x[find ../../ -name "package.json" | grep "/react-native-gesture-handler/package.json" | grep -v "/.yarn/"]
-  libInstancesArray = libInstances.split("\n")
-  if libInstancesArray.length() > 1
-    parsedLocation = ''
-    for location in libInstancesArray
-      location['../../'] = '- '
-      location['/package.json'] = ''
-      parsedLocation += location + "\n"
-    end
-    raise "[Gesture Handler] Multiple versions of Gesture Handler were detected. Only one instance of react-native-gesture-handler can be installed in a project. You need to resolve the conflict manually. Check out the documentation: https://docs.swmansion.com/react-native-gesture-handler/docs/troubleshooting#multiple-versions-of-reanimated-were-detected \n\nConflict between: \n" + parsedLocation
-  end
-end
-
 Pod::Spec.new do |s|
   # NPM package specification
   package = JSON.parse(File.read(File.join(File.dirname(__FILE__), "package.json")))

package/android/build.gradle

@@ -68,14 +68,6 @@ if (project == rootProject) {
     apply from: "spotless.gradle"
 }
 
-def shouldAssertNoMultipleInstances() {
-  if (rootProject.hasProperty("disableMultipleInstancesCheck")) {
-    return rootProject.property("disableMultipleInstancesCheck") != "true"
-  } else {
-    return true
-  }
-}
-
 // Check whether Reanimated 2.3 or higher is installed alongside Gesture Handler
 def shouldUseCommonInterfaceFromReanimated() {
     def reanimated = rootProject.subprojects.find { it.name == 'react-native-reanimated' }
@@ -103,71 +95,12 @@ file("$REACT_NATIVE_DIR/ReactAndroid/gradle.properties").withInputStream { react
 def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME")
 def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.startsWith("0.0.0-") ? 1000 : REACT_NATIVE_VERSION.split("\\.")[1].toInteger()
 
-
-abstract class NoMultipleInstancesAssertionTask extends DefaultTask {
-    @Inject abstract ObjectFactory getObjectFactory()
-
-    @Input abstract Property<File> getProjectDirFile()
-    @Input abstract Property<File> getRootDirFile()
-    @Input abstract Property<Boolean> getShouldCheck()
-
-    def findGestureHandlerInstancesForPath(String path) {
-        return objectFactory.fileTree().from(path)
-                .include("**/react-native-gesture-handler/package.json")
-                .exclude("**/.yarn/**")
-                .exclude({ Files.isSymbolicLink(it.getFile().toPath()) })
-                .findAll()
-    }
-
-    @TaskAction
-    def check() {
-        if (shouldCheck.get()) {
-            // Assert there are no multiple installations of Gesture Handler
-            Set<File> files
-
-            if (projectDirFile.get().parent.contains(rootDirFile.get().parent)) {
-                // standard app
-                files = findGestureHandlerInstancesForPath(rootDirFile.get().parent + "/node_modules")
-            } else {
-                // monorepo
-                files = findGestureHandlerInstancesForPath(rootDirFile.get().parent + "/node_modules")
-                files.addAll(
-                    findGestureHandlerInstancesForPath(projectDirFile.get().parentFile.parent)
-                )
-            }
-
-            if (files.size() > 1) {
-                String parsedLocation = files.stream().map({
-                    File file -> "- " + file.toString().replace("/package.json", "")
-                }).collect().join("\n")
-                String exceptionMessage = "\n[react-native-gesture-handler] Multiple versions of Gesture Handler " +
-                        "were detected. Only one instance of react-native-gesture-handler can be installed in a " +
-                        "project. You need to resolve the conflict manually. Check out the documentation: " +
-                        "https://docs.swmansion.com/react-native-gesture-handler/docs/troubleshooting" +
-                        "#multiple-instances-of-gesture-handler-were-detected \n\nConflict between: \n" +
-                        parsedLocation + "\n"
-                throw new GradleException(exceptionMessage)
-            }
-        }
-    }
-}
-
-tasks.register('assertNoMultipleInstances', NoMultipleInstancesAssertionTask) {
-    shouldCheck = shouldAssertNoMultipleInstances()
-    rootDirFile = rootDir
-    projectDirFile = projectDir
-}
-
- tasks.preBuild {
-     dependsOn assertNoMultipleInstances
- }
-
 repositories {
     mavenCentral()
 }
 
 android {
-    compileSdkVersion safeExtGet("compileSdkVersion", 28)
+    compileSdkVersion safeExtGet("compileSdkVersion", 33)
     def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
     if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
         namespace "com.swmansion.gesturehandler"
@@ -189,8 +122,8 @@ android {
     }
 
     defaultConfig {
-        minSdkVersion safeExtGet('minSdkVersion', 16)
-        targetSdkVersion safeExtGet('targetSdkVersion', 28)
+        minSdkVersion safeExtGet('minSdkVersion', 21)
+        targetSdkVersion safeExtGet('targetSdkVersion', 33)
         versionCode 1
         versionName "1.0"
         buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
@@ -256,12 +189,8 @@ android {
 def kotlin_version = safeExtGet('kotlinVersion', project.properties['RNGH_kotlinVersion'])
 
 dependencies {
-    //noinspection GradleDynamicVersion
-    if (REACT_NATIVE_MINOR_VERSION >= 71) {
-        implementation "com.facebook.react:react-android" // version substituted by RNGP
-    } else {
-        implementation 'com.facebook.react:react-native:+' // from node_modules
-    }
+    implementation 'com.facebook.react:react-native:+' // from node_modules
+    
 
     if (shouldUseCommonInterfaceFromReanimated()) {
         // Include Reanimated as dependency to load the common interface

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

@@ -371,7 +371,14 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     lastAbsolutePositionY = GestureUtils.getLastPointerY(adaptedTransformedEvent, true)
     lastEventOffsetX = adaptedTransformedEvent.rawX - adaptedTransformedEvent.x
     lastEventOffsetY = adaptedTransformedEvent.rawY - adaptedTransformedEvent.y
-    onHandle(adaptedTransformedEvent, adaptedSourceEvent)
+    if (sourceEvent.action == MotionEvent.ACTION_HOVER_ENTER ||
+      sourceEvent.action == MotionEvent.ACTION_HOVER_MOVE ||
+      sourceEvent.action == MotionEvent.ACTION_HOVER_EXIT
+    ) {
+      onHandleHover(adaptedTransformedEvent, adaptedSourceEvent)
+    } else {
+      onHandle(adaptedTransformedEvent, adaptedSourceEvent)
+    }
     if (adaptedTransformedEvent != transformedEvent) {
       adaptedTransformedEvent.recycle()
     }
@@ -675,6 +682,8 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     moveToState(STATE_FAILED)
   }
 
+  protected open fun onHandleHover(event: MotionEvent, sourceEvent: MotionEvent) {}
+
   protected open fun onStateChange(newState: Int, previousState: Int) {}
   protected open fun onReset() {}
   protected open fun onCancel() {}
@@ -706,6 +715,12 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     onReset()
   }
 
+  fun withMarkedAsInBounds(closure: () -> Unit) {
+    isWithinBounds = true
+    closure()
+    isWithinBounds = false
+  }
+
   fun setOnTouchEventListener(listener: OnTouchEventListener?): GestureHandler<*> {
     onTouchEventListener = listener
     return this

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

@@ -37,7 +37,7 @@ class GestureHandlerOrchestrator(
   fun onTouchEvent(event: MotionEvent): Boolean {
     isHandlingTouch = true
     val action = event.actionMasked
-    if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_POINTER_DOWN) {
+    if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_POINTER_DOWN || action == MotionEvent.ACTION_HOVER_MOVE) {
       extractGestureHandlers(event)
     } else if (action == MotionEvent.ACTION_CANCEL) {
       cancelAll()
@@ -295,7 +295,7 @@ class GestureHandlerOrchestrator(
 
       // if event was of type UP or POINTER_UP we request handler to stop tracking now that
       // the event has been dispatched
-      if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_POINTER_UP) {
+      if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_HOVER_EXIT) {
         val pointerId = event.getPointerId(event.actionIndex)
         handler.stopTrackingPointer(pointerId)
       }
@@ -325,6 +325,8 @@ class GestureHandlerOrchestrator(
     return parent === wrapperView
   }
 
+  fun isAnyHandlerActive() = gestureHandlers.any { it?.state == GestureHandler.STATE_ACTIVE }
+
   /**
    * Transforms an event in the coordinates of wrapperView into the coordinate space of the received view.
    *
@@ -464,16 +466,24 @@ class GestureHandlerOrchestrator(
     return found
   }
 
-  private fun recordViewHandlersForPointer(view: View, coords: FloatArray, pointerId: Int): Boolean {
+  private fun recordViewHandlersForPointer(view: View, coords: FloatArray, pointerId: Int, event: MotionEvent): Boolean {
     var found = false
     handlerRegistry.getHandlersForView(view)?.let {
       synchronized(it) {
         for (handler in it) {
-          if (handler.isEnabled && handler.isWithinBounds(view, coords[0], coords[1])) {
-            recordHandlerIfNotPresent(handler, view)
-            handler.startTrackingPointer(pointerId)
-            found = true
+          // skip disabled and out-of-bounds handlers
+          if (!handler.isEnabled || !handler.isWithinBounds(view, coords[0], coords[1])) {
+            continue
+          }
+
+          // we don't want to extract gestures other than hover when processing hover events
+          if (event.action in listOf(MotionEvent.ACTION_HOVER_EXIT, MotionEvent.ACTION_HOVER_ENTER, MotionEvent.ACTION_HOVER_MOVE) && handler !is HoverGestureHandler) {
+            continue
           }
+
+          recordHandlerIfNotPresent(handler, view)
+          handler.startTrackingPointer(pointerId)
+          found = true
         }
       }
     }
@@ -494,11 +504,11 @@ class GestureHandlerOrchestrator(
     val pointerId = event.getPointerId(actionIndex)
     tempCoords[0] = event.getX(actionIndex)
     tempCoords[1] = event.getY(actionIndex)
-    traverseWithPointerEvents(wrapperView, tempCoords, pointerId)
-    extractGestureHandlers(wrapperView, tempCoords, pointerId)
+    traverseWithPointerEvents(wrapperView, tempCoords, pointerId, event)
+    extractGestureHandlers(wrapperView, tempCoords, pointerId, event)
   }
 
-  private fun extractGestureHandlers(viewGroup: ViewGroup, coords: FloatArray, pointerId: Int): Boolean {
+  private fun extractGestureHandlers(viewGroup: ViewGroup, coords: FloatArray, pointerId: Int, event: MotionEvent): Boolean {
     val childrenCount = viewGroup.childCount
     for (i in childrenCount - 1 downTo 0) {
       val child = viewConfigHelper.getChildInDrawingOrderAtIndex(viewGroup, i)
@@ -513,7 +523,7 @@ class GestureHandlerOrchestrator(
         if (!isClipping(child) || isTransformedTouchPointInView(coords[0], coords[1], child)) {
           // we only consider the view if touch is inside the view bounds or if the view's children
           // can render outside of the view bounds (overflow visible)
-          found = traverseWithPointerEvents(child, coords, pointerId)
+          found = traverseWithPointerEvents(child, coords, pointerId, event)
         }
         coords[0] = restoreX
         coords[1] = restoreY
@@ -525,7 +535,7 @@ class GestureHandlerOrchestrator(
     return false
   }
 
-  private fun traverseWithPointerEvents(view: View, coords: FloatArray, pointerId: Int): Boolean =
+  private fun traverseWithPointerEvents(view: View, coords: FloatArray, pointerId: Int, event: MotionEvent): Boolean =
     when (viewConfigHelper.getPointerEventsConfigForView(view)) {
       PointerEventsConfig.NONE -> {
         // This view and its children can't be the target
@@ -534,7 +544,7 @@ class GestureHandlerOrchestrator(
       PointerEventsConfig.BOX_ONLY -> {
         // This view is the target, its children don't matter
         (
-          recordViewHandlersForPointer(view, coords, pointerId) ||
+          recordViewHandlersForPointer(view, coords, pointerId, event) ||
             shouldHandlerlessViewBecomeTouchTarget(view, coords)
           )
       }
@@ -542,10 +552,10 @@ class GestureHandlerOrchestrator(
         // This view can't be the target, but its children might
         when (view) {
           is ViewGroup -> {
-            extractGestureHandlers(view, coords, pointerId).also { found ->
+            extractGestureHandlers(view, coords, pointerId, event).also { found ->
               // A child view is handling touch, also extract handlers attached to this view
               if (found) {
-                recordViewHandlersForPointer(view, coords, pointerId)
+                recordViewHandlersForPointer(view, coords, pointerId, event)
               }
             }
           }
@@ -554,7 +564,7 @@ class GestureHandlerOrchestrator(
           // handlers attached to the text input, as it makes sense that gestures would work on a
           // non-editable TextInput.
           is EditText -> {
-            recordViewHandlersForPointer(view, coords, pointerId)
+            recordViewHandlersForPointer(view, coords, pointerId, event)
           }
           else -> false
         }
@@ -562,11 +572,11 @@ class GestureHandlerOrchestrator(
       PointerEventsConfig.AUTO -> {
         // Either this view or one of its children is the target
         val found = if (view is ViewGroup) {
-          extractGestureHandlers(view, coords, pointerId)
+          extractGestureHandlers(view, coords, pointerId, event)
         } else false
 
         (
-          recordViewHandlersForPointer(view, coords, pointerId) ||
+          recordViewHandlersForPointer(view, coords, pointerId, event) ||
             found || shouldHandlerlessViewBecomeTouchTarget(view, coords)
           )
       }
@@ -580,6 +590,21 @@ class GestureHandlerOrchestrator(
   private fun isClipping(view: View) =
     view !is ViewGroup || viewConfigHelper.isViewClippingChildren(view)
 
+  fun activateNativeHandlersForView(view: View) {
+    handlerRegistry.getHandlersForView(view)?.forEach {
+      if (it !is NativeViewGestureHandler) {
+        return@forEach
+      }
+      this.recordHandlerIfNotPresent(it, view)
+
+      it.withMarkedAsInBounds {
+        it.begin()
+        it.activate()
+        it.end()
+      }
+    }
+  }
+
   companion object {
     // The limit doesn't necessarily need to exists, it was just simpler to implement it that way
     // it is also more allocation-wise efficient to have a fixed limit

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

@@ -0,0 +1,120 @@
+package com.swmansion.gesturehandler.core
+
+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.RNViewConfigurationHelper
+
+class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
+  private var handler: Handler? = null
+  private var finishRunnable = Runnable { finish() }
+
+  private infix fun isAncestorOf(other: GestureHandler<*>): Boolean {
+    var current: View? = other.view
+
+    while (current != null) {
+      if (current == this.view) {
+        return true
+      }
+
+      current = current.parent as? View
+    }
+
+    return false
+  }
+
+  private fun isViewDisplayedOverAnother(view: View, other: View, rootView: View = view.rootView): Boolean? {
+    // traverse the tree starting on the root view, to see which view will be drawn first
+    if (rootView == other) {
+      return true
+    }
+
+    if (rootView == view) {
+      return false
+    }
+
+    if (rootView is ViewGroup) {
+      for (i in 0 until rootView.childCount) {
+        val child = viewConfigHelper.getChildInDrawingOrderAtIndex(rootView, i)
+        return isViewDisplayedOverAnother(view, other, child) ?: continue
+      }
+    }
+
+    return null
+  }
+
+  override fun shouldBeCancelledBy(handler: GestureHandler<*>): Boolean {
+    if (handler is HoverGestureHandler && !(handler isAncestorOf this)) {
+      return isViewDisplayedOverAnother(handler.view!!, this.view!!)!!
+    }
+
+    return super.shouldBeCancelledBy(handler)
+  }
+
+  override fun shouldRequireToWaitForFailure(handler: GestureHandler<*>): Boolean {
+    if (handler is HoverGestureHandler) {
+      if (!(this isAncestorOf handler) && !(handler isAncestorOf this)) {
+        isViewDisplayedOverAnother(this.view!!, handler.view!!)?.let {
+          return it
+        }
+      }
+    }
+
+    return super.shouldRequireToWaitForFailure(handler)
+  }
+
+  override fun shouldRecognizeSimultaneously(handler: GestureHandler<*>): Boolean {
+    if (handler is HoverGestureHandler && (this isAncestorOf handler || handler isAncestorOf this)) {
+      return true
+    }
+
+    return super.shouldRecognizeSimultaneously(handler)
+  }
+
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    if (event.action == MotionEvent.ACTION_DOWN) {
+      handler?.removeCallbacksAndMessages(null)
+      handler = null
+    } else if (event.action == MotionEvent.ACTION_UP) {
+      if (!isWithinBounds) {
+        finish()
+      }
+    }
+  }
+
+  override fun onHandleHover(event: MotionEvent, sourceEvent: MotionEvent) {
+    when {
+      event.action == MotionEvent.ACTION_HOVER_EXIT -> {
+        if (handler == null) {
+          handler = Handler(Looper.getMainLooper())
+        }
+
+        handler!!.postDelayed(finishRunnable, 4)
+      }
+
+      !isWithinBounds -> {
+        finish()
+      }
+
+      this.state == STATE_UNDETERMINED &&
+        (event.action == MotionEvent.ACTION_HOVER_MOVE || event.action == MotionEvent.ACTION_HOVER_ENTER) -> {
+        begin()
+        activate()
+      }
+    }
+  }
+
+  private fun finish() {
+    when (this.state) {
+      STATE_UNDETERMINED -> cancel()
+      STATE_BEGAN -> fail()
+      STATE_ACTIVE -> end()
+    }
+  }
+
+  companion object {
+    private val viewConfigHelper = RNViewConfigurationHelper()
+  }
+}

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

@@ -6,6 +6,7 @@ import android.view.View
 import android.view.ViewConfiguration
 import android.view.ViewGroup
 import android.widget.ScrollView
+import com.facebook.react.views.scroll.ReactScrollView
 import com.facebook.react.views.swiperefresh.ReactSwipeRefreshLayout
 import com.facebook.react.views.textinput.ReactEditText
 
@@ -75,6 +76,7 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
       is NativeViewGestureHandlerHook -> this.hook = view
       is ReactEditText -> this.hook = EditTextHook(this, view)
       is ReactSwipeRefreshLayout -> this.hook = SwipeRefreshLayoutHook(this, view)
+      is ReactScrollView -> this.hook = ScrollViewHook()
     }
   }
 
@@ -120,6 +122,7 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
       action = MotionEvent.ACTION_CANCEL
     }
     view!!.onTouchEvent(event)
+    event.recycle()
   }
 
   override fun onReset() {
@@ -247,4 +250,8 @@ class NativeViewGestureHandler : GestureHandler<NativeViewGestureHandler>() {
       // oh well  ¯\_(ツ)_/¯
     }
   }
+
+  private class ScrollViewHook : NativeViewGestureHandlerHook {
+    override fun shouldCancelRootViewGestureHandlerIfNecessary() = true
+  }
 }

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

@@ -1,5 +1,7 @@
 package com.swmansion.gesturehandler.react
 
+import android.content.Context
+import android.view.accessibility.AccessibilityManager
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.facebook.react.uimanager.UIManagerModule
@@ -9,3 +11,6 @@ val ReactContext.deviceEventEmitter: DeviceEventManagerModule.RCTDeviceEventEmit
 
 val ReactContext.UIManager: UIManagerModule
   get() = this.getNativeModule(UIManagerModule::class.java)!!
+
+fun Context.isScreenReaderOn() =
+  (getSystemService(Context.ACCESSIBILITY_SERVICE) as AccessibilityManager).isEnabled

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

@@ -13,10 +13,12 @@ import android.graphics.drawable.ShapeDrawable
 import android.graphics.drawable.shapes.RectShape
 import android.os.Build
 import android.util.TypedValue
+import android.view.KeyEvent
 import android.view.MotionEvent
 import android.view.View
 import android.view.View.OnClickListener
 import android.view.ViewGroup
+import android.view.ViewParent
 import androidx.core.view.children
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.PixelUtil
@@ -119,6 +121,7 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
     private var needBackgroundUpdate = false
     private var lastEventTime = -1L
     private var lastAction = -1
+    private var receivedKeyEvent = false
 
     var isTouched = false
 
@@ -128,6 +131,7 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       isClickable = true
       isFocusable = true
       needBackgroundUpdate = true
+      clipChildren = false
     }
 
     private inline fun withBackgroundUpdate(block: () -> Unit) {
@@ -170,6 +174,7 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
     override fun onTouchEvent(event: MotionEvent): Boolean {
       if (event.action == MotionEvent.ACTION_CANCEL) {
         tryFreeingResponder()
+        return super.onTouchEvent(event)
       }
 
       val eventTime = event.eventTime
@@ -208,7 +213,7 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
         // Therefore it might be used as long as:
         // 1. ReactViewManager is not a generic class with a possibility to handle another ViewGroup
         // 2. There's no way to force native behavior of ReactViewGroup's superclass's onTouchEvent
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && selectable is RippleDrawable) {
+        if (selectable is RippleDrawable) {
           val mask = PaintDrawable(Color.WHITE)
           mask.setCornerRadius(borderRadius)
           selectable.setDrawableByLayerId(android.R.id.mask, mask)
@@ -235,16 +240,8 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
     }
 
     private fun createSelectableDrawable(): Drawable? {
-      // TODO: remove once support for RN 0.63 is dropped, since 0.64 minSdkVersion is 21
-      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
-        context.theme.resolveAttribute(android.R.attr.selectableItemBackground, resolveOutValue, true)
-        @Suppress("Deprecation")
-        return resources.getDrawable(resolveOutValue.resourceId)
-      }
-
-      // Since Android 13, alpha channel in RippleDrawable is clamped between [128, 255]
-      // see https://github.com/aosp-mirror/platform_frameworks_base/blob/c1bd0480261460584753508327ca8a0c6fc80758/graphics/java/android/graphics/drawable/RippleDrawable.java#L1012
-      if (rippleColor == Color.TRANSPARENT && Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      // don't create ripple drawable at all when it's not supposed to be visible
+      if (rippleColor == Color.TRANSPARENT) {
         return null
       }
 
@@ -333,13 +330,30 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       return false
     }
 
+    override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
+      receivedKeyEvent = true
+      return super.onKeyUp(keyCode, event)
+    }
+
     override fun performClick(): Boolean {
       // don't preform click when a child button is pressed (mainly to prevent sound effect of
       // a parent button from playing)
-      return if (!isChildTouched() && soundResponder == this) {
-        tryFreeingResponder()
-        soundResponder = null
-        super.performClick()
+      return if (!isChildTouched()) {
+
+        if (context.isScreenReaderOn()) {
+          findGestureHandlerRootView()?.activateNativeHandlers(this)
+        } else if (receivedKeyEvent) {
+          findGestureHandlerRootView()?.activateNativeHandlers(this)
+          receivedKeyEvent = false
+        }
+
+        if (soundResponder === this) {
+          tryFreeingResponder()
+          soundResponder = null
+          super.performClick()
+        } else {
+          false
+        }
       } else {
         false
       }
@@ -356,7 +370,6 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
           soundResponder = this
         }
       }
-
       // button can be pressed alongside other button if both are non-exclusive and it doesn't have
       // any pressed children (to prevent pressing the parent when children is pressed).
       val canBePressedAlongsideOther = !exclusive && touchResponder?.exclusive != true && !isChildTouched()
@@ -378,6 +391,20 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       // 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/RNGestureHandlerModule.kt

@@ -20,6 +20,7 @@ import com.swmansion.gesturehandler.BuildConfig
 import com.swmansion.gesturehandler.ReanimatedEventDispatcher
 import com.swmansion.gesturehandler.core.FlingGestureHandler
 import com.swmansion.gesturehandler.core.GestureHandler
+import com.swmansion.gesturehandler.core.HoverGestureHandler
 import com.swmansion.gesturehandler.core.LongPressGestureHandler
 import com.swmansion.gesturehandler.core.ManualGestureHandler
 import com.swmansion.gesturehandler.core.NativeViewGestureHandler
@@ -337,6 +338,25 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
     }
   }
 
+  private class HoverGestureHandlerFactory : HandlerFactory<HoverGestureHandler>() {
+    override val type = HoverGestureHandler::class.java
+    override val name = "HoverGestureHandler"
+
+    override fun create(context: Context?): HoverGestureHandler {
+      return HoverGestureHandler()
+    }
+
+    override fun extractEventData(handler: HoverGestureHandler, eventData: WritableMap) {
+      super.extractEventData(handler, eventData)
+      with(eventData) {
+        putDouble("x", PixelUtil.toDIPFromPixel(handler.lastRelativePositionX).toDouble())
+        putDouble("y", PixelUtil.toDIPFromPixel(handler.lastRelativePositionY).toDouble())
+        putDouble("absoluteX", PixelUtil.toDIPFromPixel(handler.lastPositionInWindowX).toDouble())
+        putDouble("absoluteY", PixelUtil.toDIPFromPixel(handler.lastPositionInWindowY).toDouble())
+      }
+    }
+  }
+
   private val eventListener = object : OnTouchEventListener {
     override fun <T : GestureHandler<T>> onHandlerUpdate(handler: T, event: MotionEvent) {
       this@RNGestureHandlerModule.onHandlerUpdate(handler)
@@ -359,6 +379,7 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
     RotationGestureHandlerFactory(),
     FlingGestureHandlerFactory(),
     ManualGestureHandlerFactory(),
+    HoverGestureHandlerFactory(),
   )
   val registry: RNGestureHandlerRegistry = RNGestureHandlerRegistry()
   private val interactionManager = RNGestureHandlerInteractionManager()