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

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

@@ -0,0 +1,33 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.core.LongPressGestureHandler
+
+class LongPressGestureHandlerEventDataBuilder(handler: LongPressGestureHandler) : GestureHandlerEventDataBuilder<LongPressGestureHandler>(handler) {
+  private val x: Float
+  private val y: Float
+  private val absoluteX: Float
+  private val absoluteY: Float
+  private val duration: Int
+
+  init {
+    x = handler.lastRelativePositionX
+    y = handler.lastRelativePositionY
+    absoluteX = handler.lastPositionInWindowX
+    absoluteY = handler.lastPositionInWindowY
+    duration = handler.duration
+  }
+
+  override fun buildEventData(eventData: WritableMap) {
+    super.buildEventData(eventData)
+
+    with(eventData) {
+      putDouble("x", PixelUtil.toDIPFromPixel(x).toDouble())
+      putDouble("y", PixelUtil.toDIPFromPixel(y).toDouble())
+      putDouble("absoluteX", PixelUtil.toDIPFromPixel(absoluteX).toDouble())
+      putDouble("absoluteY", PixelUtil.toDIPFromPixel(absoluteY).toDouble())
+      putInt("duration", duration)
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.swmansion.gesturehandler.core.ManualGestureHandler
+
+class ManualGestureHandlerEventDataBuilder(handler: ManualGestureHandler) : GestureHandlerEventDataBuilder<ManualGestureHandler>(handler)

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

@@ -0,0 +1,18 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.swmansion.gesturehandler.core.NativeViewGestureHandler
+
+class NativeGestureHandlerEventDataBuilder(handler: NativeViewGestureHandler) : GestureHandlerEventDataBuilder<NativeViewGestureHandler>(handler) {
+  private val pointerInside: Boolean
+
+  init {
+    pointerInside = handler.isWithinBounds
+  }
+
+  override fun buildEventData(eventData: WritableMap) {
+    super.buildEventData(eventData)
+
+    eventData.putBoolean("pointerInside", pointerInside)
+  }
+}

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

@@ -0,0 +1,42 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.core.PanGestureHandler
+
+class PanGestureHandlerEventDataBuilder(handler: PanGestureHandler) : GestureHandlerEventDataBuilder<PanGestureHandler>(handler) {
+  private val x: Float
+  private val y: Float
+  private val absoluteX: Float
+  private val absoluteY: Float
+  private val translationX: Float
+  private val translationY: Float
+  private val velocityX: Float
+  private val velocityY: Float
+
+  init {
+    x = handler.lastRelativePositionX
+    y = handler.lastRelativePositionY
+    absoluteX = handler.lastPositionInWindowX
+    absoluteY = handler.lastPositionInWindowY
+    translationX = handler.translationX
+    translationY = handler.translationY
+    velocityX = handler.velocityX
+    velocityY = handler.velocityY
+  }
+
+  override fun buildEventData(eventData: WritableMap) {
+    super.buildEventData(eventData)
+
+    with(eventData) {
+      putDouble("x", PixelUtil.toDIPFromPixel(x).toDouble())
+      putDouble("y", PixelUtil.toDIPFromPixel(y).toDouble())
+      putDouble("absoluteX", PixelUtil.toDIPFromPixel(absoluteX).toDouble())
+      putDouble("absoluteY", PixelUtil.toDIPFromPixel(absoluteY).toDouble())
+      putDouble("translationX", PixelUtil.toDIPFromPixel(translationX).toDouble())
+      putDouble("translationY", PixelUtil.toDIPFromPixel(translationY).toDouble())
+      putDouble("velocityX", PixelUtil.toDIPFromPixel(velocityX).toDouble())
+      putDouble("velocityY", PixelUtil.toDIPFromPixel(velocityY).toDouble())
+    }
+  }
+}

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

@@ -0,0 +1,30 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.core.PinchGestureHandler
+
+class PinchGestureHandlerEventDataBuilder(handler: PinchGestureHandler) : GestureHandlerEventDataBuilder<PinchGestureHandler>(handler) {
+  private val scale: Double
+  private val focalX: Float
+  private val focalY: Float
+  private val velocity: Double
+
+  init {
+    scale = handler.scale
+    focalX = handler.focalPointX
+    focalY = handler.focalPointY
+    velocity = handler.velocity
+  }
+
+  override fun buildEventData(eventData: WritableMap) {
+    super.buildEventData(eventData)
+
+    with(eventData) {
+      putDouble("scale", scale)
+      putDouble("focalX", PixelUtil.toDIPFromPixel(focalX).toDouble())
+      putDouble("focalY", PixelUtil.toDIPFromPixel(focalY).toDouble())
+      putDouble("velocity", velocity)
+    }
+  }
+}

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

@@ -0,0 +1,30 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.core.RotationGestureHandler
+
+class RotationGestureHandlerEventDataBuilder(handler: RotationGestureHandler) : GestureHandlerEventDataBuilder<RotationGestureHandler>(handler) {
+  private val rotation: Double
+  private val anchorX: Float
+  private val anchorY: Float
+  private val velocity: Double
+
+  init {
+    rotation = handler.rotation
+    anchorX = handler.anchorX
+    anchorY = handler.anchorY
+    velocity = handler.velocity
+  }
+
+  override fun buildEventData(eventData: WritableMap) {
+    super.buildEventData(eventData)
+
+    with(eventData) {
+      putDouble("rotation", rotation)
+      putDouble("anchorX", PixelUtil.toDIPFromPixel(anchorX).toDouble())
+      putDouble("anchorY", PixelUtil.toDIPFromPixel(anchorY).toDouble())
+      putDouble("velocity", velocity)
+    }
+  }
+}

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

@@ -0,0 +1,30 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.core.TapGestureHandler
+
+class TapGestureHandlerEventDataBuilder(handler: TapGestureHandler) : GestureHandlerEventDataBuilder<TapGestureHandler>(handler) {
+  private val x: Float
+  private val y: Float
+  private val absoluteX: Float
+  private val absoluteY: Float
+
+  init {
+    x = handler.lastRelativePositionX
+    y = handler.lastRelativePositionY
+    absoluteX = handler.lastPositionInWindowX
+    absoluteY = handler.lastPositionInWindowY
+  }
+
+  override fun buildEventData(eventData: WritableMap) {
+    super.buildEventData(eventData)
+
+    with(eventData) {
+      putDouble("x", PixelUtil.toDIPFromPixel(x).toDouble())
+      putDouble("y", PixelUtil.toDIPFromPixel(y).toDouble())
+      putDouble("absoluteX", PixelUtil.toDIPFromPixel(absoluteX).toDouble())
+      putDouble("absoluteY", PixelUtil.toDIPFromPixel(absoluteY).toDouble())
+    }
+  }
+}

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

@@ -0,0 +1,37 @@
+project(GestureHandler)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+if(${REACT_NATIVE_MINOR_VERSION} GREATER_EQUAL 73)
+    set(CMAKE_CXX_STANDARD 20)
+else()
+    set(CMAKE_CXX_STANDARD 17)
+endif()
+
+set(PACKAGE_NAME "gesturehandler")
+set(REACT_ANDROID_DIR "${REACT_NATIVE_DIR}/ReactAndroid")
+
+include(${REACT_ANDROID_DIR}/cmake-utils/folly-flags.cmake)
+add_compile_options(${folly_FLAGS})
+
+add_library(${PACKAGE_NAME}
+  SHARED
+  cpp-adapter.cpp
+)
+
+target_include_directories(
+  ${PACKAGE_NAME}
+  PRIVATE
+  "${REACT_NATIVE_DIR}/ReactCommon"
+)
+
+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
+)

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

@@ -0,0 +1,44 @@
+#include <jni.h>
+#include <jsi/jsi.h>
+
+#include <react/renderer/uimanager/primitives.h>
+
+using namespace facebook;
+using namespace react;
+
+void decorateRuntime(jsi::Runtime &runtime) {
+  auto isFormsStackingContext = jsi::Function::createFromHostFunction(
+      runtime,
+      jsi::PropNameID::forAscii(runtime, "isFormsStackingContext"),
+      1,
+      [](jsi::Runtime &runtime,
+         const jsi::Value &thisValue,
+         const jsi::Value *arguments,
+         size_t count) -> jsi::Value {
+        if (!arguments[0].isObject()) {
+          return jsi::Value::null();
+        }
+
+        auto shadowNode = arguments[0]
+                              .asObject(runtime)
+                              .getHostObject<ShadowNodeWrapper>(runtime)
+                              ->shadowNode;
+        bool isFormsStackingContext = shadowNode->getTraits().check(
+            ShadowNodeTraits::FormsStackingContext);
+
+        return jsi::Value(isFormsStackingContext);
+      });
+  runtime.global().setProperty(
+      runtime, "isFormsStackingContext", std::move(isFormsStackingContext));
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_swmansion_gesturehandler_react_RNGestureHandlerModule_decorateRuntime(
+    JNIEnv *env,
+    jobject clazz,
+    jlong jsiPtr) {
+  jsi::Runtime *runtime = reinterpret_cast<jsi::Runtime *>(jsiPtr);
+  if (runtime) {
+    decorateRuntime(*runtime);
+  }
+}

package/ios/Handlers/RNFlingHandler.h

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

package/ios/Handlers/RNFlingHandler.m

@@ -0,0 +1,152 @@
+#import "RNFlingHandler.h"
+
+@interface RNBetterSwipeGestureRecognizer : UISwipeGestureRecognizer
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+
+@end
+
+@implementation RNBetterSwipeGestureRecognizer {
+  __weak RNGestureHandler *_gestureHandler;
+  CGPoint _lastPoint; // location of the most recently updated touch, relative to the view
+  bool _hasBegan; // whether the `BEGAN` event has been sent
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:gestureHandler action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+    _lastPoint = CGPointZero;
+    _hasBegan = NO;
+  }
+  return self;
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  _lastPoint = [[[touches allObjects] objectAtIndex:0] locationInView:_gestureHandler.recognizer.view];
+  [_gestureHandler reset];
+  [super touchesBegan:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
+
+  // self.numberOfTouches doesn't work for this because in case than one finger is required,
+  // when holding one finger on the screen and tapping with the second one, numberOfTouches is equal
+  // to 2 only for the first tap but 1 for all the following ones
+  if (!_hasBegan) {
+    [self triggerAction];
+    _hasBegan = YES;
+  }
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  _lastPoint = [[[touches allObjects] objectAtIndex:0] locationInView:_gestureHandler.recognizer.view];
+  [super touchesMoved:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  _lastPoint = [[[touches allObjects] objectAtIndex:0] locationInView:_gestureHandler.recognizer.view];
+  [super touchesEnded:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  _lastPoint = [[[touches allObjects] objectAtIndex:0] locationInView:_gestureHandler.recognizer.view];
+  [super touchesCancelled:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+}
+
+- (void)triggerAction
+{
+  [_gestureHandler handleGesture:self];
+}
+
+- (void)reset
+{
+  [self triggerAction];
+  [_gestureHandler.pointerTracker reset];
+  _hasBegan = NO;
+  [super reset];
+}
+
+- (CGPoint)getLastLocation
+{
+  // I think keeping the location of only one touch is enough since it would be used to determine the direction
+  // of the movement, and if it's wrong the recognizer fails anyway.
+  // In case the location of all touches is required, touch events are the way to go
+  return _lastPoint;
+}
+
+@end
+
+@implementation RNFlingGestureHandler
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+  if ((self = [super initWithTag:tag])) {
+    _recognizer = [[RNBetterSwipeGestureRecognizer alloc] initWithGestureHandler:self];
+  }
+  return self;
+}
+- (void)resetConfig
+{
+  [super resetConfig];
+  UISwipeGestureRecognizer *recognizer = (UISwipeGestureRecognizer *)_recognizer;
+  recognizer.direction = UISwipeGestureRecognizerDirectionRight;
+#if !TARGET_OS_TV
+  recognizer.numberOfTouchesRequired = 1;
+#endif
+}
+
+- (void)configure:(NSDictionary *)config
+{
+  [super configure:config];
+  UISwipeGestureRecognizer *recognizer = (UISwipeGestureRecognizer *)_recognizer;
+
+  id prop = config[@"direction"];
+  if (prop != nil) {
+    recognizer.direction = [RCTConvert NSInteger:prop];
+  }
+
+#if !TARGET_OS_TV
+  prop = config[@"numberOfPointers"];
+  if (prop != nil) {
+    recognizer.numberOfTouchesRequired = [RCTConvert NSInteger:prop];
+  }
+#endif
+}
+
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer
+{
+  RNGestureHandlerState savedState = _lastState;
+  BOOL shouldBegin = [super gestureRecognizerShouldBegin:gestureRecognizer];
+  _lastState = savedState;
+
+  return shouldBegin;
+}
+
+- (RNGestureHandlerEventExtraData *)eventExtraData:(id)_recognizer
+{
+  // For some weird reason [recognizer locationInView:recognizer.view.window] returns (0, 0).
+  // To calculate the correct absolute position, first calculate the absolute position of the
+  // view inside the root view controller (https://stackoverflow.com/a/7448573) and then
+  // add the relative touch position to it.
+
+  RNBetterSwipeGestureRecognizer *recognizer = (RNBetterSwipeGestureRecognizer *)_recognizer;
+
+  CGPoint viewAbsolutePosition =
+      [recognizer.view convertPoint:recognizer.view.bounds.origin
+                             toView:[UIApplication sharedApplication].keyWindow.rootViewController.view];
+  CGPoint locationInView = [recognizer getLastLocation];
+
+  return [RNGestureHandlerEventExtraData
+               forPosition:locationInView
+      withAbsolutePosition:CGPointMake(
+                               viewAbsolutePosition.x + locationInView.x, viewAbsolutePosition.y + locationInView.y)
+       withNumberOfTouches:recognizer.numberOfTouches];
+}
+
+@end

package/ios/Handlers/RNForceTouchHandler.h

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

package/ios/Handlers/RNForceTouchHandler.m

@@ -0,0 +1,175 @@
+#import "RNForceTouchHandler.h"
+
+#import <UIKit/UIGestureRecognizerSubclass.h>
+
+#import <React/RCTConvert.h>
+
+@interface RNForceTouchGestureRecognizer : UIGestureRecognizer
+
+@property (nonatomic) CGFloat maxForce;
+@property (nonatomic) CGFloat minForce;
+@property (nonatomic) CGFloat force;
+@property (nonatomic) BOOL feedbackOnActivation;
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+
+@end
+
+@implementation RNForceTouchGestureRecognizer {
+  __weak RNGestureHandler *_gestureHandler;
+  UITouch *_firstTouch;
+}
+
+static const CGFloat defaultForce = 0;
+static const CGFloat defaultMinForce = 0.2;
+static const CGFloat defaultMaxForce = NAN;
+static const BOOL defaultFeedbackOnActivation = NO;
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:gestureHandler action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+    _force = defaultForce;
+    _minForce = defaultMinForce;
+    _maxForce = defaultMaxForce;
+    _feedbackOnActivation = defaultFeedbackOnActivation;
+  }
+  return self;
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (_firstTouch) {
+    // ignore rest of fingers
+    return;
+  }
+  [super touchesBegan:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
+
+  _firstTouch = [touches anyObject];
+  [self handleForceWithTouches:touches];
+  self.state = UIGestureRecognizerStatePossible;
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (![touches containsObject:_firstTouch]) {
+    // Considered only the very first touch
+    return;
+  }
+  [super touchesMoved:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
+
+  [self handleForceWithTouches:touches];
+
+  if ([self shouldFail]) {
+    self.state = UIGestureRecognizerStateFailed;
+    return;
+  }
+
+  if (self.state == UIGestureRecognizerStatePossible && [self shouldActivate]) {
+    [self performFeedbackIfRequired];
+    self.state = UIGestureRecognizerStateBegan;
+  }
+}
+
+- (BOOL)shouldActivate
+{
+  return (_force >= _minForce);
+}
+
+- (BOOL)shouldFail
+{
+  return TEST_MAX_IF_NOT_NAN(_force, _maxForce);
+}
+
+- (void)performFeedbackIfRequired
+{
+#if !TARGET_OS_TV
+  if (_feedbackOnActivation) {
+    if (@available(iOS 10.0, *)) {
+      [[[UIImpactFeedbackGenerator alloc] initWithStyle:(UIImpactFeedbackStyleMedium)] impactOccurred];
+    }
+  }
+#endif
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (![touches containsObject:_firstTouch]) {
+    // Considered only the very first touch
+    return;
+  }
+  [super touchesEnded:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+  if (self.state == UIGestureRecognizerStateBegan || self.state == UIGestureRecognizerStateChanged) {
+    self.state = UIGestureRecognizerStateEnded;
+  } else {
+    self.state = UIGestureRecognizerStateFailed;
+  }
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+}
+
+- (void)handleForceWithTouches:(NSSet<UITouch *> *)touches
+{
+  _force = _firstTouch.force / _firstTouch.maximumPossibleForce;
+}
+
+- (void)reset
+{
+  [_gestureHandler.pointerTracker reset];
+  [super reset];
+  _force = 0;
+  _firstTouch = NULL;
+}
+
+@end
+
+@implementation RNForceTouchHandler
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+  if ((self = [super initWithTag:tag])) {
+    _recognizer = [[RNForceTouchGestureRecognizer alloc] initWithGestureHandler:self];
+  }
+  return self;
+}
+
+- (void)resetConfig
+{
+  [super resetConfig];
+  RNForceTouchGestureRecognizer *recognizer = (RNForceTouchGestureRecognizer *)_recognizer;
+
+  recognizer.feedbackOnActivation = defaultFeedbackOnActivation;
+  recognizer.maxForce = defaultMaxForce;
+  recognizer.minForce = defaultMinForce;
+}
+
+- (void)configure:(NSDictionary *)config
+{
+  [super configure:config];
+  RNForceTouchGestureRecognizer *recognizer = (RNForceTouchGestureRecognizer *)_recognizer;
+
+  APPLY_FLOAT_PROP(maxForce);
+  APPLY_FLOAT_PROP(minForce);
+
+  id prop = config[@"feedbackOnActivation"];
+  if (prop != nil) {
+    recognizer.feedbackOnActivation = [RCTConvert BOOL:prop];
+  }
+}
+
+- (RNGestureHandlerEventExtraData *)eventExtraData:(RNForceTouchGestureRecognizer *)recognizer
+{
+  return [RNGestureHandlerEventExtraData forForce:recognizer.force
+                                      forPosition:[recognizer locationInView:recognizer.view]
+                             withAbsolutePosition:[recognizer locationInView:recognizer.view.window]
+                              withNumberOfTouches:recognizer.numberOfTouches];
+}
+
+@end

package/ios/Handlers/RNHoverHandler.h

@@ -0,0 +1,12 @@
+//
+//  RNHoverHandler.h
+//  RNGestureHandler
+//
+//  Created by Jakub Piasecki on 31/03/2023.
+//
+
+#import "RNGestureHandler.h"
+
+API_AVAILABLE(ios(13.4))
+@interface RNHoverGestureHandler : RNGestureHandler
+@end