react-native-gesture-handler 2.18.0 → 2.19.0

package/README.md

@@ -37,6 +37,7 @@ You will need to have an Android or iOS device or emulator connected.
 
 | version | react-native version |
 | ------- | -------------------- |
+| 2.18.0+ | 0.73.0+              |
 | 2.16.0+ | 0.68.0+              |
 | 2.14.0+ | 0.67.0+              |
 | 2.10.0+ | 0.64.0+              |

package/android/build.gradle

@@ -1,8 +1,5 @@
 import groovy.json.JsonSlurper
 
-import javax.inject.Inject
-import java.nio.file.Files
-
 buildscript {
     def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['RNGH_kotlinVersion']
 
@@ -98,15 +95,11 @@ repositories {
 
 android {
     compileSdkVersion safeExtGet("compileSdkVersion", 33)
-    def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
-    if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
-        namespace "com.swmansion.gesturehandler"
-    }
 
-    if (agpVersion.tokenize('.')[0].toInteger() >= 8) {
-        buildFeatures {
-            buildConfig = true
-        }
+    namespace "com.swmansion.gesturehandler"
+    buildFeatures {
+        buildConfig = true
+        prefab = true
     }
 
     // Used to override the NDK path/version on internal CI or by allowing
@@ -118,12 +111,6 @@ android {
         ndkVersion rootProject.ext.ndkVersion
     }
 
-    if (REACT_NATIVE_MINOR_VERSION >= 71) {
-        buildFeatures {
-            prefab true
-        }
-    }
-
     defaultConfig {
         minSdkVersion safeExtGet('minSdkVersion', 21)
         targetSdkVersion safeExtGet('targetSdkVersion', 33)

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.swmansion.gesturehandler">
-</manifest>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

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

@@ -397,19 +397,19 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
   }
 
-  private fun dispatchTouchDownEvent(event: MotionEvent) {
+  private fun dispatchTouchDownEvent(event: MotionEvent, sourceEvent: MotionEvent) {
     changedTouchesPayload = null
     touchEventType = RNGestureHandlerTouchEvent.EVENT_TOUCH_DOWN
     val pointerId = event.getPointerId(event.actionIndex)
-    val offsetX = event.rawX - event.x
-    val offsetY = event.rawY - event.y
+    val offsetX = sourceEvent.rawX - sourceEvent.x
+    val offsetY = sourceEvent.rawY - sourceEvent.y
 
     trackedPointers[pointerId] = PointerData(
       pointerId,
       event.getX(event.actionIndex),
       event.getY(event.actionIndex),
-      event.getX(event.actionIndex) + offsetX - windowOffset[0],
-      event.getY(event.actionIndex) + offsetY - windowOffset[1],
+      sourceEvent.getX(event.actionIndex) + offsetX - windowOffset[0],
+      sourceEvent.getY(event.actionIndex) + offsetY - windowOffset[1],
     )
     trackedPointersCount++
     addChangedPointer(trackedPointers[pointerId]!!)
@@ -418,20 +418,20 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     dispatchTouchEvent()
   }
 
-  private fun dispatchTouchUpEvent(event: MotionEvent) {
+  private fun dispatchTouchUpEvent(event: MotionEvent, sourceEvent: MotionEvent) {
     extractAllPointersData()
     changedTouchesPayload = null
     touchEventType = RNGestureHandlerTouchEvent.EVENT_TOUCH_UP
     val pointerId = event.getPointerId(event.actionIndex)
-    val offsetX = event.rawX - event.x
-    val offsetY = event.rawY - event.y
+    val offsetX = sourceEvent.rawX - sourceEvent.x
+    val offsetY = sourceEvent.rawY - sourceEvent.y
 
     trackedPointers[pointerId] = PointerData(
       pointerId,
       event.getX(event.actionIndex),
       event.getY(event.actionIndex),
-      event.getX(event.actionIndex) + offsetX - windowOffset[0],
-      event.getY(event.actionIndex) + offsetY - windowOffset[1],
+      sourceEvent.getX(event.actionIndex) + offsetX - windowOffset[0],
+      sourceEvent.getY(event.actionIndex) + offsetY - windowOffset[1],
     )
     addChangedPointer(trackedPointers[pointerId]!!)
     trackedPointers[pointerId] = null
@@ -440,11 +440,11 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     dispatchTouchEvent()
   }
 
-  private fun dispatchTouchMoveEvent(event: MotionEvent) {
+  private fun dispatchTouchMoveEvent(event: MotionEvent, sourceEvent: MotionEvent) {
     changedTouchesPayload = null
     touchEventType = RNGestureHandlerTouchEvent.EVENT_TOUCH_MOVE
-    val offsetX = event.rawX - event.x
-    val offsetY = event.rawY - event.y
+    val offsetX = sourceEvent.rawX - sourceEvent.x
+    val offsetY = sourceEvent.rawY - sourceEvent.y
     var pointersAdded = 0
 
     for (i in 0 until event.pointerCount) {
@@ -454,8 +454,8 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
       if (pointer.x != event.getX(i) || pointer.y != event.getY(i)) {
         pointer.x = event.getX(i)
         pointer.y = event.getY(i)
-        pointer.absoluteX = event.getX(i) + offsetX - windowOffset[0]
-        pointer.absoluteY = event.getY(i) + offsetY - windowOffset[1]
+        pointer.absoluteX = sourceEvent.getX(i) + offsetX - windowOffset[0]
+        pointer.absoluteY = sourceEvent.getY(i) + offsetY - windowOffset[1]
 
         addChangedPointer(pointer)
         pointersAdded++
@@ -471,15 +471,15 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
   }
 
-  fun updatePointerData(event: MotionEvent) {
+  fun updatePointerData(event: MotionEvent, sourceEvent: MotionEvent) {
     if (event.actionMasked == MotionEvent.ACTION_DOWN || event.actionMasked == MotionEvent.ACTION_POINTER_DOWN) {
-      dispatchTouchDownEvent(event)
-      dispatchTouchMoveEvent(event)
+      dispatchTouchDownEvent(event, sourceEvent)
+      dispatchTouchMoveEvent(event, sourceEvent)
     } else if (event.actionMasked == MotionEvent.ACTION_UP || event.actionMasked == MotionEvent.ACTION_POINTER_UP) {
-      dispatchTouchMoveEvent(event)
-      dispatchTouchUpEvent(event)
+      dispatchTouchMoveEvent(event, sourceEvent)
+      dispatchTouchUpEvent(event, sourceEvent)
     } else if (event.actionMasked == MotionEvent.ACTION_MOVE) {
-      dispatchTouchMoveEvent(event)
+      dispatchTouchMoveEvent(event, sourceEvent)
     }
   }
 

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

@@ -270,7 +270,7 @@ class GestureHandlerOrchestrator(
     // the first `onTouchesDown` event after the handler processes it and changes state
     // to `BEGAN`.
     if (handler.needsPointerData && handler.state != 0) {
-      handler.updatePointerData(event)
+      handler.updatePointerData(event, sourceEvent)
     }
 
     if (!handler.isAwaiting || action != MotionEvent.ACTION_MOVE) {
@@ -292,7 +292,7 @@ class GestureHandlerOrchestrator(
       }
 
       if (handler.needsPointerData && isFirstEvent) {
-        handler.updatePointerData(event)
+        handler.updatePointerData(event, sourceEvent)
       }
 
       // if event was of type UP or POINTER_UP we request handler to stop tracking now that

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

@@ -5,6 +5,7 @@ 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
 
 class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
@@ -70,6 +71,10 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
       return true
     }
 
+    if (handler is RNGestureHandlerRootHelper.RootViewGestureHandler) {
+      return true
+    }
+
     return super.shouldRecognizeSimultaneously(handler)
   }
 

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

@@ -12,11 +12,13 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
     get() = (previousTime - startTime).toInt()
   private val defaultMaxDistSq: Float
   private var maxDistSq: 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)
@@ -24,6 +26,7 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
     val defaultMaxDist = DEFAULT_MAX_DIST_DP * context.resources.displayMetrics.density
     defaultMaxDistSq = defaultMaxDist * defaultMaxDist
     maxDistSq = defaultMaxDistSq
+    numberOfPointersRequired = 1
   }
 
   override fun resetConfig() {
@@ -37,6 +40,37 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
     return this
   }
 
+  fun setNumberOfPointers(numberOfPointers: Int): LongPressGestureHandler {
+    numberOfPointersRequired = numberOfPointers
+    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
@@ -46,8 +80,28 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
       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)
@@ -56,20 +110,37 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
       }
     }
     if (sourceEvent.actionMasked == MotionEvent.ACTION_UP || sourceEvent.actionMasked == MotionEvent.ACTION_BUTTON_RELEASE) {
+      currentPointers--
+
       handler?.let {
         it.removeCallbacksAndMessages(null)
         handler = null
       }
+
       if (state == STATE_ACTIVE) {
         end()
       } 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 (state == STATE_ACTIVE) {
           cancel()
@@ -97,6 +168,11 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
     super.dispatchHandlerUpdate(event)
   }
 
+  override fun onReset() {
+    super.onReset()
+    currentPointers = 0
+  }
+
   companion object {
     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/PinchGestureHandler.kt

@@ -23,7 +23,8 @@ class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
     override fun onScale(detector: ScaleGestureDetector): Boolean {
       val prevScaleFactor: Double = scale
       scale *= detector.scaleFactor.toDouble()
-      val delta = detector.timeDelta
+      val delta = detector.timeDeltaSeconds
+
       if (delta > 0) {
         velocity = (scale - prevScaleFactor) / delta
       }

package/android/src/main/java/com/swmansion/gesturehandler/core/ScaleGestureDetector.java

@@ -547,6 +547,16 @@ public class ScaleGestureDetector {
         return mCurrTime - mPrevTime;
     }
 
+    /**
+     * Return the time difference in seconds between the previous
+     * accepted scaling event and the current scaling event.
+     *
+     * @return Time difference since the last scaling event in seconds.
+     */
+    public double getTimeDeltaSeconds() {
+        return (double)this.getTimeDelta() / 1000;
+    }
+
     /**
      * Return the event time of the current event being processed.
      *

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

@@ -13,7 +13,7 @@ class Vector(val x: Double, val y: Double) {
   val magnitude = hypot(x, y)
 
   init {
-    val isMagnitudeSufficient = magnitude > MINIMAL_MAGNITUDE
+    val isMagnitudeSufficient = magnitude > MINIMAL_RECOGNIZABLE_MAGNITUDE
 
     unitX = if (isMagnitudeSufficient) x / magnitude else 0.0
     unitY = if (isMagnitudeSufficient) y / magnitude else 0.0
@@ -39,7 +39,7 @@ class Vector(val x: Double, val y: Double) {
     private val VECTOR_LEFT_DOWN: Vector = Vector(-1.0, 1.0)
 
     private val VECTOR_ZERO: Vector = Vector(0.0, 0.0)
-    private const val MINIMAL_MAGNITUDE = 0.1
+    private const val MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1
 
     fun fromDirection(direction: Int): Vector =
       when (direction) {

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

@@ -154,6 +154,9 @@ class RNGestureHandlerModule(reactContext: ReactApplicationContext?) :
       if (config.hasKey(KEY_LONG_PRESS_MAX_DIST)) {
         handler.setMaxDist(PixelUtil.toPixelFromDIP(config.getDouble(KEY_LONG_PRESS_MAX_DIST)))
       }
+      if (config.hasKey(KEY_NUMBER_OF_POINTERS)) {
+        handler.setNumberOfPointers(config.getInt(KEY_NUMBER_OF_POINTERS))
+      }
     }
 
     override fun createEventBuilder(handler: LongPressGestureHandler) = LongPressGestureHandlerEventDataBuilder(handler)

package/android/src/main/jni/cpp-adapter.cpp

@@ -19,10 +19,8 @@ void decorateRuntime(jsi::Runtime &runtime) {
                     return jsi::Value::null();
                 }
 
-                auto shadowNodeWrapper = arguments[0]
-                        .asObject(runtime).getNativeState<ShadowNodeWrapper>(runtime);
-                bool isFormsStackingContext = shadowNodeWrapper->shadowNode->getTraits()
-                        .check(ShadowNodeTraits::FormsStackingContext);
+                auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+                bool isFormsStackingContext = shadowNode->getTraits().check(ShadowNodeTraits::FormsStackingContext);
 
                 return jsi::Value(isFormsStackingContext);
             });

package/apple/Handlers/RNFlingHandler.h

@@ -1,3 +1,4 @@
+#import "../RNGHVector.h"
 #import "RNGestureHandler.h"
 
 @interface RNFlingGestureHandler : RNGestureHandler

package/apple/Handlers/RNFlingHandler.m

@@ -87,6 +87,154 @@
 
 @end
 
+#else
+
+@interface RNBetterSwipeGestureRecognizer : NSGestureRecognizer {
+  dispatch_block_t failFlingAction;
+  int maxDuration;
+  int minVelocity;
+  double defaultAlignmentCone;
+  double axialDeviationCosine;
+  double diagonalDeviationCosine;
+}
+
+@property (atomic, assign) RNGestureHandlerDirection direction;
+@property (atomic, assign) int numberOfTouchesRequired;
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+
+@end
+
+@implementation RNBetterSwipeGestureRecognizer {
+  __weak RNGestureHandler *_gestureHandler;
+
+  NSPoint startPosition;
+  double startTime;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:self action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+
+    maxDuration = 1.0;
+    minVelocity = 700;
+
+    defaultAlignmentCone = 30;
+    axialDeviationCosine = [self coneToDeviation:defaultAlignmentCone];
+    diagonalDeviationCosine = [self coneToDeviation:(90 - defaultAlignmentCone)];
+  }
+  return self;
+}
+
+- (void)handleGesture:(NSPanGestureRecognizer *)gestureRecognizer
+{
+  [_gestureHandler handleGesture:self];
+}
+
+- (void)mouseDown:(NSEvent *)event
+{
+  [super mouseDown:event];
+
+  startPosition = [self locationInView:self.view];
+  startTime = CACurrentMediaTime();
+
+  self.state = NSGestureRecognizerStatePossible;
+
+  __weak typeof(self) weakSelf = self;
+
+  failFlingAction = dispatch_block_create(0, ^{
+    __strong typeof(self) strongSelf = weakSelf;
+
+    if (strongSelf) {
+      strongSelf.state = NSGestureRecognizerStateFailed;
+    }
+  });
+
+  dispatch_after(
+      dispatch_time(DISPATCH_TIME_NOW, (int64_t)(maxDuration * NSEC_PER_SEC)),
+      dispatch_get_main_queue(),
+      failFlingAction);
+}
+
+- (void)mouseDragged:(NSEvent *)event
+{
+  [super mouseDragged:event];
+
+  NSPoint currentPosition = [self locationInView:self.view];
+  double currentTime = CACurrentMediaTime();
+
+  NSPoint distance;
+  distance.x = currentPosition.x - startPosition.x;
+  distance.y = startPosition.y - currentPosition.y;
+
+  double timeDelta = currentTime - startTime;
+
+  Vector *velocityVector = [Vector fromVelocityX:(distance.x / timeDelta) withVelocityY:(distance.y / timeDelta)];
+
+  [self tryActivate:velocityVector];
+}
+
+- (void)mouseUp:(NSEvent *)event
+{
+  [super mouseUp:event];
+
+  dispatch_block_cancel(failFlingAction);
+
+  self.state =
+      self.state == NSGestureRecognizerStateChanged ? NSGestureRecognizerStateEnded : NSGestureRecognizerStateFailed;
+}
+
+- (void)tryActivate:(Vector *)velocityVector
+{
+  bool isAligned = NO;
+
+  for (int i = 0; i < directionsSize; ++i) {
+    if ([self getAlignment:axialDirections[i]
+            withMinimalAlignmentCosine:axialDeviationCosine
+                    withVelocityVector:velocityVector]) {
+      isAligned = YES;
+      break;
+    }
+  }
+
+  if (!isAligned) {
+    for (int i = 0; i < directionsSize; ++i) {
+      if ([self getAlignment:diagonalDirections[i]
+              withMinimalAlignmentCosine:diagonalDeviationCosine
+                      withVelocityVector:velocityVector]) {
+        isAligned = YES;
+        break;
+      }
+    }
+  }
+
+  bool isFastEnough = velocityVector.magnitude >= minVelocity;
+
+  if (isAligned && isFastEnough) {
+    self.state = NSGestureRecognizerStateChanged;
+  }
+}
+
+- (BOOL)getAlignment:(RNGestureHandlerDirection)direction
+    withMinimalAlignmentCosine:(double)minimalAlignmentCosine
+            withVelocityVector:(Vector *)velocityVector
+{
+  Vector *directionVector = [Vector fromDirection:direction];
+  return ((self.direction & direction) == direction) &&
+      [velocityVector isSimilar:directionVector withThreshold:minimalAlignmentCosine];
+}
+
+- (double)coneToDeviation:(double)degrees
+{
+  double radians = (degrees * M_PI) / 180;
+  return cos(radians / 2);
+}
+
+@end
+
+#endif
+
 @implementation RNFlingGestureHandler
 
 - (instancetype)initWithTag:(NSNumber *)tag
@@ -100,8 +248,8 @@
 - (void)resetConfig
 {
   [super resetConfig];
-  UISwipeGestureRecognizer *recognizer = (UISwipeGestureRecognizer *)_recognizer;
-  recognizer.direction = UISwipeGestureRecognizerDirectionRight;
+  RNBetterSwipeGestureRecognizer *recognizer = (RNBetterSwipeGestureRecognizer *)_recognizer;
+  recognizer.direction = RNGestureHandlerDirectionRight;
 #if !TARGET_OS_TV
   recognizer.numberOfTouchesRequired = 1;
 #endif
@@ -110,7 +258,7 @@
 - (void)configure:(NSDictionary *)config
 {
   [super configure:config];
-  UISwipeGestureRecognizer *recognizer = (UISwipeGestureRecognizer *)_recognizer;
+  RNBetterSwipeGestureRecognizer *recognizer = (RNBetterSwipeGestureRecognizer *)_recognizer;
 
   id prop = config[@"direction"];
   if (prop != nil) {
@@ -125,6 +273,7 @@
 #endif
 }
 
+#if !TARGET_OS_OSX
 - (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer
 {
   RNGestureHandlerState savedState = _lastState;
@@ -154,21 +303,6 @@
        withNumberOfTouches:recognizer.numberOfTouches
            withPointerType:_pointerType];
 }
-@end
-
-#else
-
-@implementation RNFlingGestureHandler
-
-- (instancetype)initWithTag:(NSNumber *)tag
-{
-  RCTLogWarn(@"FlingGestureHandler is not supported on macOS");
-  if ((self = [super initWithTag:tag])) {
-    _recognizer = [NSGestureRecognizer alloc];
-  }
-  return self;
-}
+#endif
 
 @end
-
-#endif

package/apple/Handlers/RNHoverHandler.m

@@ -6,6 +6,7 @@
 //
 
 #import "RNHoverHandler.h"
+#import <React/UIView+React.h>
 
 #if !TARGET_OS_OSX
 
@@ -163,17 +164,58 @@ API_AVAILABLE(ios(13.4))
 
 #else
 
-@implementation RNHoverGestureHandler
+@implementation RNHoverGestureHandler {
+  NSTrackingArea *trackingArea;
+  RNGHUIView *_view;
+}
 
 - (instancetype)initWithTag:(NSNumber *)tag
 {
-  RCTLogWarn(@"HoverGestureHandler is not supported on macOS");
   if ((self = [super initWithTag:tag])) {
     _recognizer = [NSGestureRecognizer alloc];
   }
+
   return self;
 }
 
+- (void)bindToView:(RNGHUIView *)view
+{
+  _view = view;
+
+  NSTrackingAreaOptions options =
+      NSTrackingMouseEnteredAndExited | NSTrackingActiveInActiveApp | NSTrackingInVisibleRect;
+
+  trackingArea = [[NSTrackingArea alloc] initWithRect:_view.bounds options:options owner:self userInfo:nil];
+  [_view addTrackingArea:trackingArea];
+}
+
+- (void)unbindFromView
+{
+  [_view removeTrackingArea:trackingArea];
+  _view = nil;
+}
+
+- (void)mouseEntered:(NSEvent *)event
+{
+  [self sendEventsInState:RNGestureHandlerStateBegan
+           forViewWithTag:_view.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES withPointerType:_pointerType]];
+  [self sendEventsInState:RNGestureHandlerStateActive
+           forViewWithTag:_view.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES withPointerType:_pointerType]];
+}
+
+- (void)mouseExited:(NSEvent *)theEvent
+{
+  [self sendEventsInState:RNGestureHandlerStateEnd
+           forViewWithTag:_view.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES withPointerType:_pointerType]];
+
+  [self sendEventsInState:RNGestureHandlerStateUndetermined
+           forViewWithTag:_view.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES withPointerType:_pointerType]];
+}
+
 @end
 
 #endif