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

package/ios/RNGestureHandlerManager.mm

@@ -0,0 +1,367 @@
+#import "RNGestureHandlerManager.h"
+
+#import <React/RCTComponent.h>
+#import <React/RCTEventDispatcher.h>
+#import <React/RCTLog.h>
+#import <React/RCTModalHostViewController.h>
+#import <React/RCTRootContentView.h>
+#import <React/RCTRootView.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTViewManager.h>
+
+#import "RNGestureHandler.h"
+#import "RNGestureHandlerActionType.h"
+#import "RNGestureHandlerRegistry.h"
+#import "RNGestureHandlerState.h"
+#import "RNRootViewGestureRecognizer.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTFabricModalHostViewController.h>
+#import <React/RCTSurfaceTouchHandler.h>
+#import <React/RCTSurfaceView.h>
+#import <React/RCTViewComponentView.h>
+#else
+#import <React/RCTTouchHandler.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+#import "Handlers/RNFlingHandler.h"
+#import "Handlers/RNForceTouchHandler.h"
+#import "Handlers/RNHoverHandler.h"
+#import "Handlers/RNLongPressHandler.h"
+#import "Handlers/RNManualHandler.h"
+#import "Handlers/RNNativeViewHandler.h"
+#import "Handlers/RNPanHandler.h"
+#import "Handlers/RNPinchHandler.h"
+#import "Handlers/RNRotationHandler.h"
+#import "Handlers/RNTapHandler.h"
+
+// We use the method below instead of RCTLog because we log out messages after the bridge gets
+// turned down in some cases. Which normally with RCTLog would cause a crash in DEBUG mode
+#define RCTLifecycleLog(...) \
+  RCTDefaultLogFunction(     \
+      RCTLogLevelInfo, RCTLogSourceNative, @(__FILE__), @(__LINE__), [NSString stringWithFormat:__VA_ARGS__])
+
+constexpr int NEW_ARCH_NUMBER_OF_ATTACH_RETRIES = 25;
+
+@interface RNGestureHandlerManager () <RNGestureHandlerEventEmitter, RNRootViewGestureRecognizerDelegate>
+
+@end
+
+@implementation RNGestureHandlerManager {
+  RNGestureHandlerRegistry *_registry;
+  RCTUIManager *_uiManager;
+  NSHashTable<RNRootViewGestureRecognizer *> *_rootViewGestureRecognizers;
+  NSMutableDictionary<NSNumber *, NSNumber *> *_attachRetryCounter;
+  RCTEventDispatcher *_eventDispatcher;
+  id _reanimatedModule;
+}
+
+- (instancetype)initWithUIManager:(RCTUIManager *)uiManager eventDispatcher:(RCTEventDispatcher *)eventDispatcher
+{
+  if ((self = [super init])) {
+    _uiManager = uiManager;
+    _eventDispatcher = eventDispatcher;
+    _registry = [RNGestureHandlerRegistry new];
+    _rootViewGestureRecognizers = [NSHashTable hashTableWithOptions:NSPointerFunctionsWeakMemory];
+    _attachRetryCounter = [[NSMutableDictionary alloc] init];
+    _reanimatedModule = nil;
+  }
+  return self;
+}
+
+- (void)createGestureHandler:(NSString *)handlerName tag:(NSNumber *)handlerTag config:(NSDictionary *)config
+{
+  static NSDictionary *map;
+  static dispatch_once_t mapToken;
+  dispatch_once(&mapToken, ^{
+    map = @{
+      @"PanGestureHandler" : [RNPanGestureHandler class],
+      @"TapGestureHandler" : [RNTapGestureHandler class],
+      @"FlingGestureHandler" : [RNFlingGestureHandler class],
+      @"LongPressGestureHandler" : [RNLongPressGestureHandler class],
+      @"NativeViewGestureHandler" : [RNNativeViewGestureHandler class],
+      @"PinchGestureHandler" : [RNPinchGestureHandler class],
+      @"RotationGestureHandler" : [RNRotationGestureHandler class],
+      @"ForceTouchGestureHandler" : [RNForceTouchHandler class],
+      @"ManualGestureHandler" : [RNManualGestureHandler class],
+      @"HoverGestureHandler" : [RNHoverGestureHandler class],
+    };
+  });
+
+  Class nodeClass = map[handlerName];
+  if (!nodeClass) {
+    RCTLogError(@"Gesture handler type %@ is not supported", handlerName);
+    return;
+  }
+
+  RNGestureHandler *gestureHandler = [[nodeClass alloc] initWithTag:handlerTag];
+  [gestureHandler configure:config];
+  [_registry registerGestureHandler:gestureHandler];
+
+  __weak id<RNGestureHandlerEventEmitter> emitter = self;
+  gestureHandler.emitter = emitter;
+}
+
+- (void)attachGestureHandler:(nonnull NSNumber *)handlerTag
+               toViewWithTag:(nonnull NSNumber *)viewTag
+              withActionType:(RNGestureHandlerActionType)actionType
+{
+  UIView *view = [_uiManager viewForReactTag:viewTag];
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  if (view == nil || view.superview == nil) {
+    // There are a few reasons we could end up here:
+    // - the native view corresponding to the viewtag hasn't yet been created
+    // - the native view has been created, but it's not attached to window
+    // - the native view will not exist because it got flattened
+    // In the first two cases we just want to wait until the view gets created or gets attached to its superview
+    // In the third case we don't want to do anything but we cannot easily distinguish it here, hece the abomination
+    // below
+    // TODO: would be great to have a better solution, although it might require migration to the shadow nodes from
+    // viewTags
+
+    NSNumber *counter = [_attachRetryCounter objectForKey:viewTag];
+    if (counter == nil) {
+      counter = @1;
+    } else {
+      counter = [NSNumber numberWithInt:counter.intValue + 1];
+    }
+
+    if (counter.intValue > NEW_ARCH_NUMBER_OF_ATTACH_RETRIES) {
+      [_attachRetryCounter removeObjectForKey:viewTag];
+    } else {
+      [_attachRetryCounter setObject:counter forKey:viewTag];
+
+      dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0.1 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
+        [self attachGestureHandler:handlerTag toViewWithTag:viewTag withActionType:actionType];
+      });
+    }
+
+    return;
+  }
+
+  [_attachRetryCounter removeObjectForKey:viewTag];
+
+  // I think it should be moved to RNNativeViewHandler, but that would require
+  // additional logic for setting contentView.reactTag, this works for now
+  if ([view isKindOfClass:[RCTViewComponentView class]]) {
+    RCTViewComponentView *componentView = (RCTViewComponentView *)view;
+    if (componentView.contentView != nil) {
+      view = componentView.contentView;
+    }
+  }
+
+  view.reactTag = viewTag; // necessary for RNReanimated eventHash (e.g. "42onGestureHandlerEvent"), also will be
+                           // returned as event.target
+#endif // RCT_NEW_ARCH_ENABLED
+
+  [_registry attachHandlerWithTag:handlerTag toView:view withActionType:actionType];
+
+  // register view if not already there
+  [self registerViewWithGestureRecognizerAttachedIfNeeded:view];
+}
+
+- (void)updateGestureHandler:(NSNumber *)handlerTag config:(NSDictionary *)config
+{
+  RNGestureHandler *handler = [_registry handlerWithTag:handlerTag];
+  [handler configure:config];
+}
+
+- (void)dropGestureHandler:(NSNumber *)handlerTag
+{
+  [_registry dropHandlerWithTag:handlerTag];
+}
+
+- (void)dropAllGestureHandlers
+{
+  [_registry dropAllHandlers];
+}
+
+- (void)handleSetJSResponder:(NSNumber *)viewTag blockNativeResponder:(NSNumber *)blockNativeResponder
+{
+  if ([blockNativeResponder boolValue]) {
+    for (RNRootViewGestureRecognizer *recognizer in _rootViewGestureRecognizers) {
+      [recognizer blockOtherRecognizers];
+    }
+  }
+}
+
+- (void)handleClearJSResponder
+{
+  // ignore...
+}
+
+- (id)handlerWithTag:(NSNumber *)handlerTag
+{
+  return [_registry handlerWithTag:handlerTag];
+}
+
+#pragma mark Root Views Management
+
+- (void)registerViewWithGestureRecognizerAttachedIfNeeded:(UIView *)childView
+{
+#ifdef RCT_NEW_ARCH_ENABLED
+  UIView *touchHandlerView = childView;
+
+  if ([[childView reactViewController] isKindOfClass:[RCTFabricModalHostViewController class]]) {
+    touchHandlerView = [childView reactViewController].view;
+  } else {
+    while (touchHandlerView != nil && ![touchHandlerView isKindOfClass:[RCTSurfaceView class]]) {
+      touchHandlerView = touchHandlerView.superview;
+    }
+  }
+#else
+  UIView *touchHandlerView = nil;
+
+  if ([[childView reactViewController] isKindOfClass:[RCTModalHostViewController class]]) {
+    touchHandlerView = [childView reactViewController].view.subviews[0];
+  } else {
+    UIView *parent = childView;
+    while (parent != nil && ![parent respondsToSelector:@selector(touchHandler)]) {
+      parent = parent.superview;
+    }
+
+    touchHandlerView = [[parent performSelector:@selector(touchHandler)] view];
+  }
+#endif // RCT_NEW_ARCH_ENABLED
+
+  if (touchHandlerView == nil) {
+    return;
+  }
+
+  // Many views can return the same touchHandler so we check if the one we want to register
+  // is not already present in the set.
+  for (UIGestureRecognizer *recognizer in touchHandlerView.gestureRecognizers) {
+    if ([recognizer isKindOfClass:[RNRootViewGestureRecognizer class]]) {
+      return;
+    }
+  }
+
+  RCTLifecycleLog(@"[GESTURE HANDLER] Initialize gesture handler for view %@", touchHandlerView);
+  RNRootViewGestureRecognizer *recognizer = [RNRootViewGestureRecognizer new];
+  recognizer.delegate = self;
+  touchHandlerView.userInteractionEnabled = YES;
+  [touchHandlerView addGestureRecognizer:recognizer];
+  [_rootViewGestureRecognizers addObject:recognizer];
+}
+
+- (void)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    didActivateInViewWithTouchHandler:(UIView *)viewWithTouchHandler
+{
+  // Cancel touches in RN's root view in order to cancel all in-js recognizers
+
+  // As scroll events are special-cased in RN responder implementation and sending them would
+  // trigger JS responder change, we don't cancel touches if the handler that got activated is
+  // a scroll recognizer. This way root view will keep sending touchMove and touchEnd events
+  // and therefore allow JS responder to properly release the responder at the end of the touch
+  // stream.
+  // NOTE: this is not a proper fix and solving this problem requires upstream fixes to RN. In
+  // particular if we have one PanHandler and ScrollView that can work simultaniously then when
+  // the Pan handler activates it would still tigger cancel events.
+  // Once the upstream fix lands the line below along with this comment can be removed
+  if ([gestureRecognizer.view isKindOfClass:[UIScrollView class]])
+    return;
+
+  UIGestureRecognizer *touchHandler = nil;
+
+  // this way we can extract the touch handler on both architectures relatively easily
+  for (UIGestureRecognizer *recognizer in [viewWithTouchHandler gestureRecognizers]) {
+#ifdef RCT_NEW_ARCH_ENABLED
+    if ([recognizer isKindOfClass:[RCTSurfaceTouchHandler class]]) {
+#else
+    if ([recognizer isKindOfClass:[RCTTouchHandler class]]) {
+#endif // RCT_NEW_ARCH_ENABLED
+      touchHandler = recognizer;
+      break;
+    }
+  }
+  [touchHandler setEnabled:NO];
+  [touchHandler setEnabled:YES];
+}
+
+#pragma mark Events
+
+- (void)sendEvent:(RNGestureHandlerStateChange *)event withActionType:(RNGestureHandlerActionType)actionType
+{
+  switch (actionType) {
+    case RNGestureHandlerActionTypeReanimatedWorklet:
+      [self sendEventForReanimated:event];
+      break;
+
+    case RNGestureHandlerActionTypeNativeAnimatedEvent:
+      if ([event.eventName isEqualToString:@"onGestureHandlerEvent"]) {
+        [self sendEventForNativeAnimatedEvent:event];
+      } else {
+        // Although onGestureEvent prop is an Animated.event with useNativeDriver: true,
+        // onHandlerStateChange prop is still a regular JS function.
+        // Also, Animated.event is only supported with old API.
+        [self sendEventForJSFunctionOldAPI:event];
+      }
+      break;
+
+    case RNGestureHandlerActionTypeJSFunctionOldAPI:
+      [self sendEventForJSFunctionOldAPI:event];
+      break;
+
+    case RNGestureHandlerActionTypeJSFunctionNewAPI:
+      [self sendEventForJSFunctionNewAPI:event];
+      break;
+  }
+}
+
+- (void)sendEventForReanimated:(RNGestureHandlerStateChange *)event
+{
+  // Delivers the event to Reanimated.
+#ifdef RCT_NEW_ARCH_ENABLED
+  // Send event directly to Reanimated
+  if (_reanimatedModule == nil) {
+    _reanimatedModule = [_uiManager.bridge moduleForName:@"ReanimatedModule"];
+  }
+
+  [_reanimatedModule eventDispatcherWillDispatchEvent:event];
+#else
+  // In the old architecture, Reanimated overwrites RCTEventDispatcher
+  // with REAEventDispatcher and intercepts all direct events.
+  [self sendEventForDirectEvent:event];
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+- (void)sendEventForNativeAnimatedEvent:(RNGestureHandlerStateChange *)event
+{
+  // Delivers the event to NativeAnimatedModule.
+  // Currently, NativeAnimated[Turbo]Module is RCTEventDispatcherObserver so we can
+  // simply send a direct event which is handled by the observer but ignored on JS side.
+  // TODO: send event directly to NativeAnimated[Turbo]Module
+  [self sendEventForDirectEvent:event];
+}
+
+- (void)sendEventForJSFunctionOldAPI:(RNGestureHandlerStateChange *)event
+{
+  // Delivers the event to JS (old RNGH API).
+#ifdef RCT_NEW_ARCH_ENABLED
+  [self sendEventForDeviceEvent:event];
+#else
+  [self sendEventForDirectEvent:event];
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+- (void)sendEventForJSFunctionNewAPI:(RNGestureHandlerStateChange *)event
+{
+  // Delivers the event to JS (new RNGH API).
+  [self sendEventForDeviceEvent:event];
+}
+
+- (void)sendEventForDirectEvent:(RNGestureHandlerStateChange *)event
+{
+  // Delivers the event to JS as a direct event.
+  [_eventDispatcher sendEvent:event];
+}
+
+- (void)sendEventForDeviceEvent:(RNGestureHandlerStateChange *)event
+{
+  // Delivers the event to JS as a device event.
+  NSMutableDictionary *body = [[event arguments] objectAtIndex:2];
+  [_eventDispatcher sendDeviceEventWithName:@"onGestureHandlerStateChange" body:body];
+}
+
+@end

package/ios/RNGestureHandlerModule.h

@@ -0,0 +1,7 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTUIManager.h>
+
+@interface RNGestureHandlerModule : RCTEventEmitter <RCTBridgeModule>
+
+@end

package/ios/RNGestureHandlerModule.mm

@@ -0,0 +1,320 @@
+#import "RNGestureHandlerModule.h"
+
+#import <React/RCTComponent.h>
+#import <React/RCTLog.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTUIManagerObserverCoordinator.h>
+#import <React/RCTUIManagerUtils.h>
+#import <React/RCTViewManager.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
+#import <React/RCTSurfacePresenter.h>
+#import <React/RCTUtils.h>
+#import <ReactCommon/CallInvoker.h>
+#import <ReactCommon/RCTTurboModule.h>
+
+#import <react/renderer/uimanager/primitives.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+#import "RNGestureHandler.h"
+#import "RNGestureHandlerDirection.h"
+#import "RNGestureHandlerManager.h"
+#import "RNGestureHandlerState.h"
+
+#import "RNGestureHandlerButton.h"
+#import "RNGestureHandlerStateManager.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+using namespace facebook;
+using namespace react;
+#endif // RCT_NEW_ARCH_ENABLED
+
+#ifdef RCT_NEW_ARCH_ENABLED
+@interface RNGestureHandlerModule () <RCTSurfacePresenterObserver, RNGestureHandlerStateManager>
+
+@end
+#else
+@interface RNGestureHandlerModule () <RCTUIManagerObserver, RNGestureHandlerStateManager>
+
+@end
+#endif // RCT_NEW_ARCH_ENABLED
+
+typedef void (^GestureHandlerOperation)(RNGestureHandlerManager *manager);
+
+@implementation RNGestureHandlerModule {
+  RNGestureHandlerManager *_manager;
+
+  // Oparations called after views have been updated.
+  NSMutableArray<GestureHandlerOperation> *_operations;
+}
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+- (void)invalidate
+{
+  RNGestureHandlerManager *handlerManager = _manager;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [handlerManager dropAllGestureHandlers];
+  });
+
+  _manager = nil;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  [self.bridge.surfacePresenter removeObserver:self];
+#else
+  [self.bridge.uiManager.observerCoordinator removeObserver:self];
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+- (dispatch_queue_t)methodQueue
+{
+  // This module needs to be on the same queue as the UIManager to avoid
+  // having to lock `_operations` and `_preOperations` since `uiManagerWillFlushUIBlocks`
+  // will be called from that queue.
+
+  // This is required as this module rely on having all the view nodes created before
+  // gesture handlers can be associated with them
+  return RCTGetUIManagerQueue();
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+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));
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  [super setBridge:bridge];
+
+  _manager = [[RNGestureHandlerManager alloc] initWithUIManager:bridge.uiManager
+                                                eventDispatcher:bridge.eventDispatcher];
+  _operations = [NSMutableArray new];
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  [bridge.surfacePresenter addObserver:self];
+#else
+  [bridge.uiManager.observerCoordinator addObserver:self];
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
+{
+  RCTCxxBridge *cxxBridge = (RCTCxxBridge *)self.bridge;
+  auto runtime = (jsi::Runtime *)cxxBridge.runtime;
+  decorateRuntime(*runtime);
+  return @true;
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+RCT_EXPORT_METHOD(createGestureHandler
+                  : (nonnull NSString *)handlerName tag
+                  : (nonnull NSNumber *)handlerTag config
+                  : (NSDictionary *)config)
+{
+  [self addOperationBlock:^(RNGestureHandlerManager *manager) {
+    [manager createGestureHandler:handlerName tag:handlerTag config:config];
+  }];
+}
+
+RCT_EXPORT_METHOD(attachGestureHandler
+                  : (nonnull NSNumber *)handlerTag toViewWithTag
+                  : (nonnull NSNumber *)viewTag actionType
+                  : (nonnull NSNumber *)actionType)
+{
+  [self addOperationBlock:^(RNGestureHandlerManager *manager) {
+    [manager attachGestureHandler:handlerTag
+                    toViewWithTag:viewTag
+                   withActionType:(RNGestureHandlerActionType)[actionType integerValue]];
+  }];
+}
+
+RCT_EXPORT_METHOD(updateGestureHandler : (nonnull NSNumber *)handlerTag config : (NSDictionary *)config)
+{
+  [self addOperationBlock:^(RNGestureHandlerManager *manager) {
+    [manager updateGestureHandler:handlerTag config:config];
+  }];
+}
+
+RCT_EXPORT_METHOD(dropGestureHandler : (nonnull NSNumber *)handlerTag)
+{
+  [self addOperationBlock:^(RNGestureHandlerManager *manager) {
+    [manager dropGestureHandler:handlerTag];
+  }];
+}
+
+RCT_EXPORT_METHOD(handleSetJSResponder
+                  : (nonnull NSNumber *)viewTag blockNativeResponder
+                  : (nonnull NSNumber *)blockNativeResponder)
+{
+  [self addOperationBlock:^(RNGestureHandlerManager *manager) {
+    [manager handleSetJSResponder:viewTag blockNativeResponder:blockNativeResponder];
+  }];
+}
+
+RCT_EXPORT_METHOD(handleClearJSResponder)
+{
+  [self addOperationBlock:^(RNGestureHandlerManager *manager) {
+    [manager handleClearJSResponder];
+  }];
+}
+
+RCT_EXPORT_METHOD(flushOperations)
+{
+  // On the new arch we rely on `flushOperations` for scheduling the operations on the UI thread.
+  // On the old arch we rely on `uiManagerWillPerformMounting`
+#ifdef RCT_NEW_ARCH_ENABLED
+  if (_operations.count == 0) {
+    return;
+  }
+
+  NSArray<GestureHandlerOperation> *operations = _operations;
+  _operations = [NSMutableArray new];
+
+  [self.bridge.uiManager
+      addUIBlock:^(__unused RCTUIManager *manager, __unused NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        for (GestureHandlerOperation operation in operations) {
+          operation(self->_manager);
+        }
+      }];
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+- (void)setGestureState:(int)state forHandler:(int)handlerTag
+{
+  RNGestureHandler *handler = [_manager handlerWithTag:@(handlerTag)];
+
+  if (handler != nil) {
+    if (state == 1) { // FAILED
+      handler.recognizer.state = UIGestureRecognizerStateFailed;
+    } else if (state == 2) { // BEGAN
+      handler.recognizer.state = UIGestureRecognizerStatePossible;
+    } else if (state == 3) { // CANCELLED
+      handler.recognizer.state = UIGestureRecognizerStateCancelled;
+    } else if (state == 4) { // ACTIVE
+      [handler stopActivationBlocker];
+      handler.recognizer.state = UIGestureRecognizerStateBegan;
+    } else if (state == 5) { // ENDED
+      handler.recognizer.state = UIGestureRecognizerStateEnded;
+    }
+  }
+
+  // if the gesture was set to finish, cancel all pointers it was tracking
+  if (state == 1 || state == 3 || state == 5) {
+    [handler.pointerTracker cancelPointers];
+  }
+
+  // do not send state change event when activating because it bypasses
+  // shouldRequireFailureOfGestureRecognizer
+  if (state != 4) {
+    [handler handleGesture:handler.recognizer];
+  }
+}
+
+#pragma mark-- Batch handling
+
+- (void)addOperationBlock:(GestureHandlerOperation)operation
+{
+  [_operations addObject:operation];
+}
+
+#pragma mark - RCTSurfacePresenterObserver
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+- (void)didMountComponentsWithRootTag:(NSInteger)rootTag
+{
+  RCTAssertMainQueue();
+
+  if (_operations.count == 0) {
+    return;
+  }
+
+  NSArray<GestureHandlerOperation> *operations = _operations;
+  _operations = [NSMutableArray new];
+
+  for (GestureHandlerOperation operation in operations) {
+    operation(self->_manager);
+  }
+}
+
+#else
+
+#pragma mark - RCTUIManagerObserver
+
+- (void)uiManagerWillFlushUIBlocks:(RCTUIManager *)uiManager
+{
+  [self uiManagerWillPerformMounting:uiManager];
+}
+
+- (void)uiManagerWillPerformMounting:(RCTUIManager *)uiManager
+{
+  if (_operations.count == 0) {
+    return;
+  }
+
+  NSArray<GestureHandlerOperation> *operations = _operations;
+  _operations = [NSMutableArray new];
+
+  [uiManager addUIBlock:^(__unused RCTUIManager *manager, __unused NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    for (GestureHandlerOperation operation in operations) {
+      operation(self->_manager);
+    }
+  }];
+}
+
+#endif // RCT_NEW_ARCH_ENABLED
+
+#pragma mark Events
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[ @"onGestureHandlerEvent", @"onGestureHandlerStateChange" ];
+}
+
+#pragma mark Module Constants
+
+- (NSDictionary *)constantsToExport
+{
+  return @{
+    @"State" : @{
+      @"UNDETERMINED" : @(RNGestureHandlerStateUndetermined),
+      @"BEGAN" : @(RNGestureHandlerStateBegan),
+      @"ACTIVE" : @(RNGestureHandlerStateActive),
+      @"CANCELLED" : @(RNGestureHandlerStateCancelled),
+      @"FAILED" : @(RNGestureHandlerStateFailed),
+      @"END" : @(RNGestureHandlerStateEnd)
+    },
+    @"Direction" : @{
+      @"RIGHT" : @(RNGestureHandlerDirectionRight),
+      @"LEFT" : @(RNGestureHandlerDirectionLeft),
+      @"UP" : @(RNGestureHandlerDirectionUp),
+      @"DOWN" : @(RNGestureHandlerDirectionDown)
+    }
+  };
+}
+
+@end