@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1

package/ios/Handlers/RNHoverHandler.m

@@ -0,0 +1,153 @@
+//
+//  RNHoverHandler.m
+//  RNGestureHandler
+//
+//  Created by Jakub Piasecki on 31/03/2023.
+//
+
+#import "RNHoverHandler.h"
+
+#import <React/RCTConvert.h>
+#import <UIKit/UIGestureRecognizerSubclass.h>
+
+#define CHECK_TARGET(__VERSION__)                                                \
+  defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_##__VERSION__) && \
+      __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_##__VERSION__ && !TARGET_OS_TV
+
+typedef NS_ENUM(NSInteger, RNGestureHandlerHoverEffect) {
+  RNGestureHandlerHoverEffectNone = 0,
+  RNGestureHandlerHoverEffectLift,
+  RNGestureHandlerHoverEffectHightlight,
+};
+
+#if CHECK_TARGET(13_4)
+
+API_AVAILABLE(ios(13.4))
+@interface RNBetterHoverGestureRecognizer : UIHoverGestureRecognizer <UIPointerInteractionDelegate>
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+
+@property (nonatomic) RNGestureHandlerHoverEffect hoverEffect;
+
+@end
+
+@implementation RNBetterHoverGestureRecognizer {
+  __weak RNGestureHandler *_gestureHandler;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:gestureHandler action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+    _hoverEffect = RNGestureHandlerHoverEffectNone;
+  }
+  return self;
+}
+
+- (void)triggerAction
+{
+  [_gestureHandler handleGesture:self];
+}
+
+- (void)cancel
+{
+  self.enabled = NO;
+}
+
+- (UIPointerStyle *)pointerInteraction:(UIPointerInteraction *)interaction styleForRegion:(UIPointerRegion *)region
+{
+  if (interaction.view != nil && _hoverEffect != RNGestureHandlerHoverEffectNone) {
+    UITargetedPreview *preview = [[UITargetedPreview alloc] initWithView:interaction.view];
+    UIPointerEffect *effect = nil;
+
+    if (_hoverEffect == RNGestureHandlerHoverEffectLift) {
+      effect = [UIPointerLiftEffect effectWithPreview:preview];
+    } else if (_hoverEffect == RNGestureHandlerHoverEffectHightlight) {
+      effect = [UIPointerHoverEffect effectWithPreview:preview];
+    }
+
+    return [UIPointerStyle styleWithEffect:effect shape:nil];
+  }
+
+  return nil;
+}
+
+@end
+
+#endif
+
+@implementation RNHoverGestureHandler {
+#if CHECK_TARGET(13_4)
+  UIPointerInteraction *_pointerInteraction;
+#endif
+}
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+#if TARGET_OS_TV
+  RCTLogWarn(@"Hover gesture handler is not supported on tvOS");
+#endif
+
+  if ((self = [super initWithTag:tag])) {
+#if CHECK_TARGET(13_4)
+    if (@available(iOS 13.4, *)) {
+      _recognizer = [[RNBetterHoverGestureRecognizer alloc] initWithGestureHandler:self];
+      _pointerInteraction =
+          [[UIPointerInteraction alloc] initWithDelegate:(id<UIPointerInteractionDelegate>)_recognizer];
+    }
+#endif
+  }
+  return self;
+}
+
+- (void)bindToView:(UIView *)view
+{
+#if CHECK_TARGET(13_4)
+  if (@available(iOS 13.4, *)) {
+    [super bindToView:view];
+    [view addInteraction:_pointerInteraction];
+  }
+#endif
+}
+
+- (void)unbindFromView
+{
+#if CHECK_TARGET(13_4)
+  if (@available(iOS 13.4, *)) {
+    [super unbindFromView];
+    [self.recognizer.view removeInteraction:_pointerInteraction];
+  }
+#endif
+}
+
+- (void)resetConfig
+{
+  [super resetConfig];
+
+#if CHECK_TARGET(13_4)
+  if (@available(iOS 13.4, *)) {
+    RNBetterHoverGestureRecognizer *recognizer = (RNBetterHoverGestureRecognizer *)_recognizer;
+    recognizer.hoverEffect = RNGestureHandlerHoverEffectNone;
+  }
+#endif
+}
+
+- (void)configure:(NSDictionary *)config
+{
+  [super configure:config];
+
+#if CHECK_TARGET(13_4)
+  if (@available(iOS 13.4, *)) {
+    RNBetterHoverGestureRecognizer *recognizer = (RNBetterHoverGestureRecognizer *)_recognizer;
+    APPLY_INT_PROP(hoverEffect);
+  }
+#endif
+}
+
+- (RNGestureHandlerEventExtraData *)eventExtraData:(UIGestureRecognizer *)recognizer
+{
+  return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:recognizer.view]
+                                withAbsolutePosition:[recognizer locationInView:recognizer.view.window]];
+}
+
+@end

package/ios/Handlers/RNLongPressHandler.h

@@ -0,0 +1,12 @@
+//
+//  RNLongPressHandler.h
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNGestureHandler.h"
+
+@interface RNLongPressGestureHandler : RNGestureHandler
+@end

package/ios/Handlers/RNLongPressHandler.m

@@ -0,0 +1,183 @@
+//
+//  RNLongPressHandler.m
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNLongPressHandler.h"
+
+#import <UIKit/UIGestureRecognizerSubclass.h>
+
+#import <React/RCTConvert.h>
+
+#import <mach/mach_time.h>
+
+@interface RNBetterLongPressGestureRecognizer : UILongPressGestureRecognizer {
+  uint64_t startTime;
+  uint64_t previousTime;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+- (void)handleGesture:(UIGestureRecognizer *)recognizer;
+- (NSUInteger)getDuration;
+
+@end
+
+@implementation RNBetterLongPressGestureRecognizer {
+  __weak RNGestureHandler *_gestureHandler;
+  CGPoint _initPosition;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:self action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+  }
+  return self;
+}
+
+- (void)handleGesture:(UIGestureRecognizer *)recognizer
+{
+  previousTime = mach_absolute_time();
+  [_gestureHandler handleGesture:recognizer];
+}
+
+- (void)triggerAction
+{
+  [self handleGesture:self];
+}
+
+- (CGPoint)translationInView
+{
+  CGPoint currentPosition = [self locationInView:self.view];
+  return CGPointMake(currentPosition.x - _initPosition.x, currentPosition.y - _initPosition.y);
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesBegan:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
+
+  _initPosition = [self locationInView:self.view];
+  startTime = mach_absolute_time();
+  [_gestureHandler reset];
+  [self triggerAction];
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [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))) {
+    self.enabled = NO;
+    self.enabled = YES;
+  }
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+}
+
+- (void)reset
+{
+  if (self.state == UIGestureRecognizerStateFailed) {
+    [self triggerAction];
+  }
+
+  [_gestureHandler.pointerTracker reset];
+
+  [super reset];
+}
+
+- (NSUInteger)getDuration
+{
+  static mach_timebase_info_data_t sTimebaseInfo;
+
+  if (sTimebaseInfo.denom == 0) {
+    mach_timebase_info(&sTimebaseInfo);
+  }
+
+  return (NSUInteger)(((previousTime - startTime) * sTimebaseInfo.numer / (sTimebaseInfo.denom * 1000000)));
+}
+
+@end
+
+@implementation RNLongPressGestureHandler
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+  if ((self = [super initWithTag:tag])) {
+    _recognizer = [[RNBetterLongPressGestureRecognizer alloc] initWithGestureHandler:self];
+  }
+  return self;
+}
+
+- (void)resetConfig
+{
+  [super resetConfig];
+  UILongPressGestureRecognizer *recognizer = (UILongPressGestureRecognizer *)_recognizer;
+
+  recognizer.minimumPressDuration = 0.5;
+  recognizer.allowableMovement = 10;
+}
+
+- (void)configure:(NSDictionary *)config
+{
+  [super configure:config];
+  UILongPressGestureRecognizer *recognizer = (UILongPressGestureRecognizer *)_recognizer;
+
+  id prop = config[@"minDurationMs"];
+  if (prop != nil) {
+    recognizer.minimumPressDuration = [RCTConvert CGFloat:prop] / 1000.0;
+  }
+
+  prop = config[@"maxDist"];
+  if (prop != nil) {
+    recognizer.allowableMovement = [RCTConvert CGFloat:prop];
+  }
+}
+
+- (RNGestureHandlerState)state
+{
+  // For long press recognizer we treat "Began" state as "active"
+  // as it changes its state to "Began" as soon as the the minimum
+  // hold duration timeout is reached, whereas state "Changed" is
+  // only set after "Began" phase if there is some movement.
+  if (_recognizer.state == UIGestureRecognizerStateBegan) {
+    return RNGestureHandlerStateActive;
+  }
+  return [super state];
+}
+
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer
+{
+  // same as TapGH, this needs to be unified when all handlers are updated
+  RNGestureHandlerState savedState = _lastState;
+  BOOL shouldBegin = [super gestureRecognizerShouldBegin:gestureRecognizer];
+  _lastState = savedState;
+
+  return shouldBegin;
+}
+
+- (RNGestureHandlerEventExtraData *)eventExtraData:(UIGestureRecognizer *)recognizer
+{
+  return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:recognizer.view]
+                                withAbsolutePosition:[recognizer locationInView:recognizer.view.window]
+                                 withNumberOfTouches:recognizer.numberOfTouches
+                                        withDuration:[(RNBetterLongPressGestureRecognizer *)recognizer getDuration]];
+}
+@end

package/ios/Handlers/RNManualHandler.h

@@ -0,0 +1,4 @@
+#import "RNGestureHandler.h"
+
+@interface RNManualGestureHandler : RNGestureHandler
+@end

package/ios/Handlers/RNManualHandler.m

@@ -0,0 +1,88 @@
+#import "RNManualHandler.h"
+
+@interface RNManualRecognizer : UIGestureRecognizer
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+
+@end
+
+@implementation RNManualRecognizer {
+  __weak RNGestureHandler *_gestureHandler;
+  BOOL _shouldSendBeginEvent;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:gestureHandler action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+    _shouldSendBeginEvent = YES;
+  }
+  return self;
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesBegan:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
+
+  if (_shouldSendBeginEvent) {
+    [_gestureHandler handleGesture:self];
+    _shouldSendBeginEvent = NO;
+  }
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
+
+  if ([self shouldFail]) {
+    self.state = (self.state == UIGestureRecognizerStatePossible) ? UIGestureRecognizerStateFailed
+                                                                  : UIGestureRecognizerStateCancelled;
+
+    [self reset];
+  }
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+}
+
+- (void)reset
+{
+  [_gestureHandler.pointerTracker reset];
+  [super reset];
+
+  _shouldSendBeginEvent = YES;
+}
+
+- (BOOL)shouldFail
+{
+  if (_gestureHandler.shouldCancelWhenOutside && ![_gestureHandler containsPointInView]) {
+    return YES;
+  } else {
+    return NO;
+  }
+}
+
+@end
+
+@implementation RNManualGestureHandler
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+  if ((self = [super initWithTag:tag])) {
+    _recognizer = [[RNManualRecognizer alloc] initWithGestureHandler:self];
+  }
+  return self;
+}
+
+@end

package/ios/Handlers/RNNativeViewHandler.h

@@ -0,0 +1,15 @@
+//
+//  RNNativeViewHandler.h
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNGestureHandler.h"
+
+@interface RNDummyGestureRecognizer : UIGestureRecognizer
+@end
+
+@interface RNNativeViewGestureHandler : RNGestureHandler
+@end

package/ios/Handlers/RNNativeViewHandler.mm

@@ -0,0 +1,193 @@
+//
+//  RNNativeViewHandler.m
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNNativeViewHandler.h"
+
+#import <UIKit/UIGestureRecognizerSubclass.h>
+
+#import <React/RCTConvert.h>
+#import <React/UIView+React.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTScrollViewComponentView.h>
+#else
+#import <React/RCTScrollView.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+#pragma mark RNDummyGestureRecognizer
+
+@implementation RNDummyGestureRecognizer {
+  __weak RNGestureHandler *_gestureHandler;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:gestureHandler action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+  }
+  return self;
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+  self.state = UIGestureRecognizerStateFailed;
+  [self reset];
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+  self.state = UIGestureRecognizerStateCancelled;
+  [self reset];
+}
+
+- (void)reset
+{
+  [_gestureHandler.pointerTracker reset];
+  [super reset];
+}
+
+@end
+
+#pragma mark RNNativeViewgestureHandler
+
+@implementation RNNativeViewGestureHandler {
+  BOOL _shouldActivateOnStart;
+  BOOL _disallowInterruption;
+}
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+  if ((self = [super initWithTag:tag])) {
+    _recognizer = [[RNDummyGestureRecognizer alloc] initWithGestureHandler:self];
+  }
+  return self;
+}
+
+- (void)configure:(NSDictionary *)config
+{
+  [super configure:config];
+  _shouldActivateOnStart = [RCTConvert BOOL:config[@"shouldActivateOnStart"]];
+  _disallowInterruption = [RCTConvert BOOL:config[@"disallowInterruption"]];
+}
+
+- (void)bindToView:(UIView *)view
+{
+  // For UIControl based views (UIButton, UISwitch) we provide special handling that would allow
+  // for properties like `disallowInterruption` to work.
+  if ([view isKindOfClass:[UIControl class]]) {
+    UIControl *control = (UIControl *)view;
+    [control addTarget:self action:@selector(handleTouchDown:forEvent:) forControlEvents:UIControlEventTouchDown];
+    [control addTarget:self
+                  action:@selector(handleTouchUpOutside:forEvent:)
+        forControlEvents:UIControlEventTouchUpOutside];
+    [control addTarget:self
+                  action:@selector(handleTouchUpInside:forEvent:)
+        forControlEvents:UIControlEventTouchUpInside];
+    [control addTarget:self action:@selector(handleDragExit:forEvent:) forControlEvents:UIControlEventTouchDragExit];
+    [control addTarget:self action:@selector(handleDragEnter:forEvent:) forControlEvents:UIControlEventTouchDragEnter];
+    [control addTarget:self action:@selector(handleTouchCancel:forEvent:) forControlEvents:UIControlEventTouchCancel];
+  } else {
+    [super bindToView:view];
+  }
+
+  // We can restore default scrollview behaviour to delay touches to scrollview's children
+  // because gesture handler system can handle cancellation of scroll recognizer when JS responder
+  // is set
+#ifdef RCT_NEW_ARCH_ENABLED
+  if ([view isKindOfClass:[RCTScrollViewComponentView class]]) {
+    UIScrollView *scrollView = ((RCTScrollViewComponentView *)view).scrollView;
+    scrollView.delaysContentTouches = YES;
+  }
+#else
+  if ([view isKindOfClass:[RCTScrollView class]]) {
+    // This part of the code is coupled with RN implementation of ScrollView native wrapper and
+    // we expect for RCTScrollView component to contain a subclass of UIScrollview as the only
+    // subview
+    UIScrollView *scrollView = [view.subviews objectAtIndex:0];
+    scrollView.delaysContentTouches = YES;
+  }
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+- (void)handleTouchDown:(UIView *)sender forEvent:(UIEvent *)event
+{
+  [self reset];
+
+  if (_disallowInterruption) {
+    // When `disallowInterruption` is set we cancel all gesture handlers when this UIControl
+    // gets DOWN event
+    for (UITouch *touch in [event allTouches]) {
+      for (UIGestureRecognizer *recogn in [touch gestureRecognizers]) {
+        recogn.enabled = NO;
+        recogn.enabled = YES;
+      }
+    }
+  }
+
+  [self sendEventsInState:RNGestureHandlerStateActive
+           forViewWithTag:sender.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES]];
+}
+
+- (void)handleTouchUpOutside:(UIView *)sender forEvent:(UIEvent *)event
+{
+  [self sendEventsInState:RNGestureHandlerStateEnd
+           forViewWithTag:sender.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:NO]];
+}
+
+- (void)handleTouchUpInside:(UIView *)sender forEvent:(UIEvent *)event
+{
+  [self sendEventsInState:RNGestureHandlerStateEnd
+           forViewWithTag:sender.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES]];
+}
+
+- (void)handleDragExit:(UIView *)sender forEvent:(UIEvent *)event
+{
+  // Pointer is moved outside of the view bounds, we cancel button when `shouldCancelWhenOutside` is set
+  if (self.shouldCancelWhenOutside) {
+    UIControl *control = (UIControl *)sender;
+    [control cancelTrackingWithEvent:event];
+    [self sendEventsInState:RNGestureHandlerStateEnd
+             forViewWithTag:sender.reactTag
+              withExtraData:[RNGestureHandlerEventExtraData forPointerInside:NO]];
+  } else {
+    [self sendEventsInState:RNGestureHandlerStateActive
+             forViewWithTag:sender.reactTag
+              withExtraData:[RNGestureHandlerEventExtraData forPointerInside:NO]];
+  }
+}
+
+- (void)handleDragEnter:(UIView *)sender forEvent:(UIEvent *)event
+{
+  [self sendEventsInState:RNGestureHandlerStateActive
+           forViewWithTag:sender.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES]];
+}
+
+- (void)handleTouchCancel:(UIView *)sender forEvent:(UIEvent *)event
+{
+  [self sendEventsInState:RNGestureHandlerStateCancelled
+           forViewWithTag:sender.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:NO]];
+}
+
+@end

package/ios/Handlers/RNPanHandler.h

@@ -0,0 +1,12 @@
+//
+//  RNPanHandler.h
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNGestureHandler.h"
+
+@interface RNPanGestureHandler : RNGestureHandler
+@end