react-native-gesture-handler 2.18.1 → 2.20.0

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/java/com/swmansion/gesturehandler/react/eventbuilders/HoverGestureHandlerEventDataBuilder.kt

@@ -3,18 +3,21 @@ package com.swmansion.gesturehandler.react.eventbuilders
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.PixelUtil
 import com.swmansion.gesturehandler.core.HoverGestureHandler
+import com.swmansion.gesturehandler.core.StylusData
 
 class HoverGestureHandlerEventDataBuilder(handler: HoverGestureHandler) : GestureHandlerEventDataBuilder<HoverGestureHandler>(handler) {
   private val x: Float
   private val y: Float
   private val absoluteX: Float
   private val absoluteY: Float
+  private val stylusData: StylusData
 
   init {
     x = handler.lastRelativePositionX
     y = handler.lastRelativePositionY
     absoluteX = handler.lastPositionInWindowX
     absoluteY = handler.lastPositionInWindowY
+    stylusData = handler.stylusData
   }
 
   override fun buildEventData(eventData: WritableMap) {
@@ -25,6 +28,10 @@ class HoverGestureHandlerEventDataBuilder(handler: HoverGestureHandler) : Gestur
       putDouble("y", PixelUtil.toDIPFromPixel(y).toDouble())
       putDouble("absoluteX", PixelUtil.toDIPFromPixel(absoluteX).toDouble())
       putDouble("absoluteY", PixelUtil.toDIPFromPixel(absoluteY).toDouble())
+
+      if (stylusData.pressure != -1.0) {
+        putMap("stylusData", stylusData.toReadableMap())
+      }
     }
   }
 }

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

@@ -3,6 +3,7 @@ package com.swmansion.gesturehandler.react.eventbuilders
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.PixelUtil
 import com.swmansion.gesturehandler.core.PanGestureHandler
+import com.swmansion.gesturehandler.core.StylusData
 
 class PanGestureHandlerEventDataBuilder(handler: PanGestureHandler) : GestureHandlerEventDataBuilder<PanGestureHandler>(handler) {
   private val x: Float
@@ -13,6 +14,7 @@ class PanGestureHandlerEventDataBuilder(handler: PanGestureHandler) : GestureHan
   private val translationY: Float
   private val velocityX: Float
   private val velocityY: Float
+  private val stylusData: StylusData
 
   init {
     x = handler.lastRelativePositionX
@@ -23,6 +25,7 @@ class PanGestureHandlerEventDataBuilder(handler: PanGestureHandler) : GestureHan
     translationY = handler.translationY
     velocityX = handler.velocityX
     velocityY = handler.velocityY
+    stylusData = handler.stylusData
   }
 
   override fun buildEventData(eventData: WritableMap) {
@@ -37,6 +40,10 @@ class PanGestureHandlerEventDataBuilder(handler: PanGestureHandler) : GestureHan
       putDouble("translationY", PixelUtil.toDIPFromPixel(translationY).toDouble())
       putDouble("velocityX", PixelUtil.toDIPFromPixel(velocityX).toDouble())
       putDouble("velocityY", PixelUtil.toDIPFromPixel(velocityY).toDouble())
+
+      if (stylusData.pressure != -1.0) {
+        putMap("stylusData", stylusData.toReadableMap())
+      }
     }
   }
 }

package/android/src/main/jni/CMakeLists.txt

@@ -26,12 +26,21 @@ target_include_directories(
 )
 
 find_package(ReactAndroid REQUIRED CONFIG)
-
-target_link_libraries(
-  gesturehandler
-  ReactAndroid::react_render_core
-  ReactAndroid::react_render_uimanager
-  ReactAndroid::react_render_graphics
-  ReactAndroid::jsi
-  ReactAndroid::react_nativemodule_core
-)
+if (ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+  target_link_libraries(
+    ${PACKAGE_NAME}
+    ReactAndroid::reactnative
+    ReactAndroid::jsi
+  )
+elseif (ReactAndroid_VERSION_MINOR GREATER_EQUAL 75)
+  target_link_libraries(
+    ${PACKAGE_NAME}
+    ReactAndroid::react_render_core
+    ReactAndroid::react_render_uimanager
+    ReactAndroid::react_render_graphics
+    ReactAndroid::jsi
+    ReactAndroid::react_nativemodule_core
+  )
+else ()
+  message(FATAL_ERROR "react-native-gesture-handler on the New Architecture requires react-native 0.75 or newer.")
+endif ()

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

package/apple/Handlers/RNLongPressHandler.m

@@ -7,22 +7,37 @@
 //
 
 #import "RNLongPressHandler.h"
+#import <React/RCTConvert.h>
 
 #if !TARGET_OS_OSX
 
 #import <UIKit/UIGestureRecognizerSubclass.h>
 
-#import <React/RCTConvert.h>
-
 @interface RNBetterLongPressGestureRecognizer : UILongPressGestureRecognizer {
+#else
+@interface RNBetterLongPressGestureRecognizer : NSGestureRecognizer {
+  dispatch_block_t block;
+#endif
+
   CFTimeInterval startTime;
   CFTimeInterval previousTime;
 }
 
+#if TARGET_OS_OSX
+@property (nonatomic, assign) double minimumPressDuration;
+@property (nonatomic, assign) double allowableMovement;
+@property (nonatomic, assign) double numberOfTouchesRequired;
+#endif
+
 - (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
-- (void)handleGesture:(UIGestureRecognizer *)recognizer;
 - (NSUInteger)getDuration;
 
+#if !TARGET_OS_OSX
+- (void)handleGesture:(UIGestureRecognizer *)recognizer;
+#else
+- (void)handleGesture:(NSGestureRecognizer *)recognizer;
+#endif
+
 @end
 
 @implementation RNBetterLongPressGestureRecognizer {
@@ -55,12 +70,16 @@
   return CGPointMake(currentPosition.x - _initPosition.x, currentPosition.y - _initPosition.y);
 }
 
+#if !TARGET_OS_OSX
+
 - (void)touchesBegan:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
 {
   [_gestureHandler setCurrentPointerType:event];
   [super touchesBegan:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
 
+  self.state = UIGestureRecognizerStatePossible;
+
   _initPosition = [self locationInView:self.view];
   startTime = CACurrentMediaTime();
   [_gestureHandler reset];
@@ -72,10 +91,8 @@
   [super touchesMoved:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
 
-  CGPoint trans = [self translationInView];
-  if ((_gestureHandler.shouldCancelWhenOutside && ![_gestureHandler containsPointInView]) ||
-      (TEST_MAX_IF_NOT_NAN(
-          fabs(trans.y * trans.y + trans.x * trans.x), self.allowableMovement * self.allowableMovement))) {
+  if ([self shouldCancelGesture]) {
+    self.state = UIGestureRecognizerStateFailed;
     self.enabled = NO;
     self.enabled = YES;
   }
@@ -94,6 +111,75 @@
   [self reset];
 }
 
+#else
+- (void)mouseDown:(NSEvent *)event
+{
+  self.state = NSGestureRecognizerStateBegan;
+  startTime = CACurrentMediaTime();
+
+  [_gestureHandler.pointerTracker touchesBegan:[NSSet setWithObject:event] withEvent:event];
+
+  _initPosition = [self locationInView:self.view];
+
+  __weak typeof(self) weakSelf = self;
+
+  block = dispatch_block_create(0, ^{
+    __strong typeof(self) strongSelf = weakSelf;
+
+    if (strongSelf) {
+      strongSelf.state = NSGestureRecognizerStateChanged;
+    }
+  });
+
+  dispatch_after(
+      dispatch_time(DISPATCH_TIME_NOW, (int64_t)(self.minimumPressDuration * NSEC_PER_SEC)),
+      dispatch_get_main_queue(),
+      block);
+}
+
+- (void)mouseDragged:(NSEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesMoved:[NSSet setWithObject:event] withEvent:event];
+
+  if (block == nil) {
+    return;
+  }
+
+  if ([self shouldCancelGesture]) {
+    dispatch_block_cancel(block);
+    block = nil;
+
+    self.state = self.state == NSGestureRecognizerStateChanged ? NSGestureRecognizerStateCancelled
+                                                               : NSGestureRecognizerStateFailed;
+  }
+}
+
+- (void)mouseUp:(NSEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesEnded:[NSSet setWithObject:event] withEvent:event];
+
+  if (block) {
+    dispatch_block_cancel(block);
+    block = nil;
+  }
+
+  self.state =
+      self.state == NSGestureRecognizerStateChanged ? NSGestureRecognizerStateEnded : NSGestureRecognizerStateFailed;
+}
+
+#endif
+
+- (BOOL)shouldCancelGesture
+{
+  CGPoint trans = [self translationInView];
+
+  BOOL shouldBeCancelledOutside = _gestureHandler.shouldCancelWhenOutside && ![_gestureHandler containsPointInView];
+  BOOL distanceExceeded =
+      TEST_MAX_IF_NOT_NAN(fabs(trans.y * trans.y + trans.x * trans.x), self.allowableMovement * self.allowableMovement);
+
+  return shouldBeCancelledOutside || distanceExceeded;
+}
+
 - (void)reset
 {
   if (self.state == UIGestureRecognizerStateFailed) {
@@ -126,7 +212,7 @@
 - (void)resetConfig
 {
   [super resetConfig];
-  UILongPressGestureRecognizer *recognizer = (UILongPressGestureRecognizer *)_recognizer;
+  RNBetterLongPressGestureRecognizer *recognizer = (RNBetterLongPressGestureRecognizer *)_recognizer;
 
   recognizer.minimumPressDuration = 0.5;
   recognizer.allowableMovement = 10;
@@ -135,7 +221,7 @@
 - (void)configure:(NSDictionary *)config
 {
   [super configure:config];
-  UILongPressGestureRecognizer *recognizer = (UILongPressGestureRecognizer *)_recognizer;
+  RNBetterLongPressGestureRecognizer *recognizer = (RNBetterLongPressGestureRecognizer *)_recognizer;
 
   id prop = config[@"minDurationMs"];
   if (prop != nil) {
@@ -146,8 +232,17 @@
   if (prop != nil) {
     recognizer.allowableMovement = [RCTConvert CGFloat:prop];
   }
+
+#if !TARGET_OS_TV
+  prop = config[@"numberOfPointers"];
+  if (prop != nil) {
+    recognizer.numberOfTouchesRequired = [RCTConvert CGFloat:prop];
+  }
+#endif
 }
 
+#if !TARGET_OS_OSX
+
 - (RNGestureHandlerState)state
 {
   // For long press recognizer we treat "Began" state as "active"
@@ -178,21 +273,17 @@
                                         withDuration:[(RNBetterLongPressGestureRecognizer *)recognizer getDuration]
                                      withPointerType:_pointerType];
 }
-@end
 
 #else
 
-@implementation RNLongPressGestureHandler
-
-- (instancetype)initWithTag:(NSNumber *)tag
+- (RNGestureHandlerEventExtraData *)eventExtraData:(NSGestureRecognizer *)recognizer
 {
-  RCTLogWarn(@"LongPressGestureHandler is not supported on macOS");
-  if ((self = [super initWithTag:tag])) {
-    _recognizer = [NSGestureRecognizer alloc];
-  }
-  return self;
+  return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:recognizer.view]
+                                withAbsolutePosition:[recognizer locationInView:recognizer.view.window.contentView]
+                                 withNumberOfTouches:1
+                                        withDuration:[(RNBetterLongPressGestureRecognizer *)recognizer getDuration]
+                                     withPointerType:RNGestureHandlerMouse];
 }
 
-@end
-
 #endif
+@end