react-native-tvos 0.71.12-0 → 0.72.4-0rc0

package/React/Fabric/RCTSurfaceTouchHandler.mm

@@ -7,46 +7,16 @@
 
 #import "RCTSurfaceTouchHandler.h"
 
-#import <React/RCTReactTaggedView.h>
+#import <React/RCTIdentifierPool.h>
 #import <React/RCTUtils.h>
 #import <React/RCTViewComponentView.h>
 
 #import "RCTConversions.h"
+#import "RCTSurfacePointerHandler.h"
 #import "RCTTouchableComponentViewProtocol.h"
 
 using namespace facebook::react;
 
-template <size_t size>
-class IdentifierPool {
- public:
-  void enqueue(int index)
-  {
-    usage[index] = false;
-  }
-
-  int dequeue()
-  {
-    while (true) {
-      if (!usage[lastIndex]) {
-        usage[lastIndex] = true;
-        return lastIndex;
-      }
-      lastIndex = (lastIndex + 1) % size;
-    }
-  }
-
-  void reset()
-  {
-    for (int i = 0; i < size; i++) {
-      usage[i] = false;
-    }
-  }
-
- private:
-  bool usage[size];
-  int lastIndex;
-};
-
 typedef NS_ENUM(NSInteger, RCTTouchEventType) {
   RCTTouchEventTypeTouchStart,
   RCTTouchEventTypeTouchMove,
@@ -58,52 +28,6 @@ struct ActiveTouch {
   Touch touch;
   SharedTouchEventEmitter eventEmitter;
 
-  /*
-   * The type of touch received.
-   */
-  UITouchType touchType;
-
-  /*
-   * The radius (in points) of the touch.
-   */
-  CGFloat majorRadius;
-
-  /*
-   * The altitude (in radians) of the stylus.
-   */
-  CGFloat altitudeAngle;
-
-  /*
-   * The azimuth angle (in radians) of the stylus.
-   */
-  CGFloat azimuthAngle;
-
-  /*
-   * The button mask of the touch
-   */
-  UIEventButtonMask buttonMask;
-
-  /*
-   * The bit mask of modifier flags in the gesture represented by the receiver.
-   */
-  UIKeyModifierFlags modifierFlags;
-
-  /*
-   * Indicates if the active touch represents the primary pointer of this pointer type.
-   */
-  bool isPrimary;
-
-  /*
-   * The button number that was pressed (if applicable) when the event was fired.
-   */
-  int button;
-
-  /*
-   * Informs the event system that when the touch is released it should be treated as the
-   * pointer leaving the screen entirely.
-   */
-  bool shouldLeaveWhenReleased;
-
   /*
    * A component view on which the touch was begun.
    */
@@ -124,97 +48,9 @@ struct ActiveTouch {
   };
 };
 
-// Mouse and Pen pointers get reserved IDs so they stay consistent no matter the order
-// at which events come in
-static int const kMousePointerId = 0;
-static int const kPencilPointerId = 1;
-
-// If a new reserved ID is added above this should be incremented to ensure touch events
-// do not conflict
-static int const kTouchIdentifierPoolOffset = 2;
-
-// Returns a CGPoint which represents the tiltX/Y values (in RADIANS)
-// Adapted from https://gist.github.com/k3a/2903719bb42b48c9198d20c2d6f73ac1
-static CGPoint SphericalToTilt(CGFloat altitudeAngleRad, CGFloat azimuthAngleRad)
-{
-  if (altitudeAngleRad == M_PI / 2.0) {
-    return CGPointMake(0.0, 0.0);
-  } else if (altitudeAngleRad == 0.0) {
-    // when pen is laying on the pad it is impossible to precisely encode but at least approximate for 4 cases
-    if (azimuthAngleRad > 7.0 * M_PI / 4.0 || azimuthAngleRad <= M_PI / 4.0) {
-      // for azimuthRad == 0, the pen is on the positive Y axis
-      return CGPointMake(0.0, M_PI / 2.0);
-    } else if (azimuthAngleRad > M_PI / 4.0 && azimuthAngleRad <= 3 * M_PI / 4.0) {
-      // for azimuthRad == math.pi/2 the pen is on the positive X axis
-      return CGPointMake(M_PI / 2.0, 0.0);
-    } else if (azimuthAngleRad > 3.0 * M_PI / 4.0 && azimuthAngleRad <= 5.0 * M_PI / 4.0) {
-      // for azimuthRad == math.pi, the pen is on the negative Y axis
-      return CGPointMake(0.0, -M_PI / 2.0);
-    } else if (azimuthAngleRad > 5.0 * M_PI / 4.0 && azimuthAngleRad <= 7.0 * M_PI / 4.0) {
-      // for azimuthRad == math.pi + math.pi/2 pen on negative X axis
-      return CGPointMake(-M_PI / 2.0, 0.0);
-    }
-  }
-
-  CGFloat tanAlt = tan(altitudeAngleRad); // tan(x) = sin(x)/cos(x)
-
-  CGFloat tiltXrad = atan(sin(azimuthAngleRad) / tanAlt);
-  CGFloat tiltYrad = atan(cos(azimuthAngleRad) / tanAlt);
-
-  return CGPointMake(tiltXrad, tiltYrad);
-}
-
-static CGFloat RadsToDegrees(CGFloat rads)
-{
-  return rads * 180 / M_PI;
-}
-
-static int ButtonMaskToButtons(UIEventButtonMask buttonMask)
-{
-#if TARGET_OS_TV
-  return 0;
-#else
-  int buttonsMaskResult = 0;
-  if (@available(iOS 13.4, *)) {
-    if ((buttonMask & UIEventButtonMaskPrimary) != 0) {
-      buttonsMaskResult |= 1;
-    }
-    if ((buttonMask & UIEventButtonMaskSecondary) != 0) {
-      buttonsMaskResult |= 2;
-    }
-    // undocumented mask value which represents the "auxiliary button" (i.e. middle mouse button)
-    if ((buttonMask & 0x4) != 0) {
-      buttonsMaskResult |= 4;
-    }
-  }
-  return buttonsMaskResult;
-#endif
-}
-
-static int ButtonMaskDiffToButton(UIEventButtonMask prevButtonMask, UIEventButtonMask curButtonMask)
-{
-#if TARGET_OS_TV
-  return 0;
-#else
-  if (@available(iOS 13.4, *)) {
-    if ((prevButtonMask & UIEventButtonMaskPrimary) != (curButtonMask & UIEventButtonMaskPrimary)) {
-      return 0;
-    }
-    if ((prevButtonMask & 0x4) != (curButtonMask & 0x4)) {
-      return 1;
-    }
-    if ((prevButtonMask & UIEventButtonMaskSecondary) != (curButtonMask & UIEventButtonMaskSecondary)) {
-      return 2;
-    }
-  }
-  return -1;
-#endif
-}
-
 static void UpdateActiveTouchWithUITouch(
     ActiveTouch &activeTouch,
     UITouch *uiTouch,
-    UIEvent *uiEvent,
     UIView *rootComponentView,
     CGPoint rootViewOriginOffset)
 {
@@ -222,7 +58,6 @@ static void UpdateActiveTouchWithUITouch(
   CGPoint pagePoint = [uiTouch locationInView:rootComponentView];
   CGPoint screenPoint = [rootComponentView convertPoint:pagePoint
                                       toCoordinateSpace:rootComponentView.window.screen.coordinateSpace];
-
   pagePoint = CGPointMake(pagePoint.x + rootViewOriginOffset.x, pagePoint.y + rootViewOriginOffset.y);
 
   activeTouch.touch.offsetPoint = RCTPointFromCGPoint(offsetPoint);
@@ -234,31 +69,9 @@ static void UpdateActiveTouchWithUITouch(
   if (RCTForceTouchAvailable()) {
     activeTouch.touch.force = RCTZeroIfNaN(uiTouch.force / uiTouch.maximumPossibleForce);
   }
-
-  activeTouch.touchType = uiTouch.type;
-  activeTouch.majorRadius = uiTouch.majorRadius;
-  activeTouch.altitudeAngle = uiTouch.altitudeAngle;
-  activeTouch.azimuthAngle = [uiTouch azimuthAngleInView:nil];
-#if !TARGET_OS_TV
-  if (@available(iOS 13.4, *)) {
-    UIEventButtonMask nextButtonMask = 0;
-    if (uiTouch.phase != UITouchPhaseEnded) {
-      nextButtonMask = uiTouch.type == UITouchTypeIndirectPointer ? uiEvent.buttonMask : 1;
-    }
-    activeTouch.button = ButtonMaskDiffToButton(activeTouch.buttonMask, nextButtonMask);
-    activeTouch.buttonMask = nextButtonMask;
-    activeTouch.modifierFlags = uiEvent.modifierFlags;
-  } else
-#endif
-  {
-    activeTouch.button = 0;
-    activeTouch.buttonMask = 0;
-    activeTouch.modifierFlags = 0;
-  }
 }
 
-static ActiveTouch
-CreateTouchWithUITouch(UITouch *uiTouch, UIEvent *uiEvent, UIView *rootComponentView, CGPoint rootViewOriginOffset)
+static ActiveTouch CreateTouchWithUITouch(UITouch *uiTouch, UIView *rootComponentView, CGPoint rootViewOriginOffset)
 {
   ActiveTouch activeTouch = {};
 
@@ -274,145 +87,9 @@ CreateTouchWithUITouch(UITouch *uiTouch, UIEvent *uiEvent, UIView *rootComponent
     }
     componentView = componentView.superview;
   }
-  UpdateActiveTouchWithUITouch(activeTouch, uiTouch, uiEvent, rootComponentView, rootViewOriginOffset);
-  return activeTouch;
-}
-
-static UIView *FindClosestFabricManagedTouchableView(UIView *componentView)
-{
-  while (componentView) {
-    if ([componentView respondsToSelector:@selector(touchEventEmitterAtPoint:)]) {
-      return componentView;
-    }
-    componentView = componentView.superview;
-  }
-  return nil;
-}
-
-static NSOrderedSet<RCTReactTaggedView *> *GetTouchableViewsInPathToRoot(UIView *componentView)
-{
-  NSMutableOrderedSet *results = [NSMutableOrderedSet orderedSet];
-  do {
-    if ([componentView respondsToSelector:@selector(touchEventEmitterAtPoint:)]) {
-      [results addObject:[RCTReactTaggedView wrap:componentView]];
-    }
-    componentView = componentView.superview;
-  } while (componentView);
-  return results;
-}
-
-static SharedTouchEventEmitter GetTouchEmitterFromView(UIView *componentView, CGPoint point)
-{
-  return [(id<RCTTouchableComponentViewProtocol>)componentView touchEventEmitterAtPoint:point];
-}
-
-static const char *PointerTypeCStringFromUITouchType(UITouchType type)
-{
-  switch (type) {
-    case UITouchTypeDirect:
-      return "touch";
-    case UITouchTypePencil:
-      return "pen";
-    case UITouchTypeIndirectPointer:
-      return "mouse";
-    case UITouchTypeIndirect:
-    default:
-      return "";
-  }
-}
-
-static void UpdatePointerEventModifierFlags(PointerEvent &event, UIKeyModifierFlags flags)
-{
-  if (@available(iOS 13.4, *)) {
-    event.ctrlKey = (flags & UIKeyModifierControl) != 0;
-    event.shiftKey = (flags & UIKeyModifierShift) != 0;
-    event.altKey = (flags & UIKeyModifierAlternate) != 0;
-    event.metaKey = (flags & UIKeyModifierCommand) != 0;
-  } else {
-    event.ctrlKey = false;
-    event.shiftKey = false;
-    event.altKey = false;
-    event.metaKey = false;
-  }
-}
-
-static PointerEvent CreatePointerEventFromActiveTouch(ActiveTouch activeTouch, RCTTouchEventType eventType)
-{
-  Touch touch = activeTouch.touch;
-
-  PointerEvent event = {};
-  event.pointerId = touch.identifier;
-  event.pointerType = PointerTypeCStringFromUITouchType(activeTouch.touchType);
-  event.clientPoint = touch.pagePoint;
-  event.screenPoint = touch.screenPoint;
-  event.offsetPoint = touch.offsetPoint;
-
-  event.pressure = touch.force;
-  if (@available(iOS 13.4, *)) {
-    if (activeTouch.touchType == UITouchTypeIndirectPointer) {
-      // pointer events with a mouse button pressed should report a pressure of 0.5
-      // when the touch is down and 0.0 when it is lifted regardless of how it is reported by the OS
-      event.pressure = eventType != RCTTouchEventTypeTouchEnd ? 0.5 : 0.0;
-    }
-  }
-
-  CGFloat pointerSize = activeTouch.majorRadius * 2.0;
-  if (@available(iOS 13.4, *)) {
-    if (activeTouch.touchType == UITouchTypeIndirectPointer) {
-      // mouse type pointers should always report a size of 1
-      pointerSize = 1.0;
-    }
-  }
-  event.width = pointerSize;
-  event.height = pointerSize;
-
-  CGPoint tilt = SphericalToTilt(activeTouch.altitudeAngle, activeTouch.azimuthAngle);
-  event.tiltX = RadsToDegrees(tilt.x);
-  event.tiltY = RadsToDegrees(tilt.y);
 
-  event.detail = 0;
-
-  event.button = activeTouch.button;
-  event.buttons = ButtonMaskToButtons(activeTouch.buttonMask);
-
-  UpdatePointerEventModifierFlags(event, activeTouch.modifierFlags);
-
-  event.tangentialPressure = 0.0;
-  event.twist = 0;
-  event.isPrimary = activeTouch.isPrimary;
-
-  return event;
-}
-
-static PointerEvent CreatePointerEventFromIncompleteHoverData(
-    CGPoint clientLocation,
-    CGPoint screenLocation,
-    CGPoint offsetLocation,
-    UIKeyModifierFlags modifierFlags)
-{
-  PointerEvent event = {};
-  // "touch" events produced from a mouse cursor on iOS always have the ID 0 so
-  // we can just assume that here since these sort of hover events only ever come
-  // from the mouse
-  event.pointerId = kMousePointerId;
-  event.pressure = 0.0;
-  event.pointerType = "mouse";
-  event.clientPoint = RCTPointFromCGPoint(clientLocation);
-  event.screenPoint = RCTPointFromCGPoint(screenLocation);
-  event.offsetPoint = RCTPointFromCGPoint(offsetLocation);
-  event.width = 1.0;
-  event.height = 1.0;
-  event.tiltX = 0;
-  event.tiltY = 0;
-  event.detail = 0;
-  event.button = -1;
-  event.buttons = 0;
-  UpdatePointerEventModifierFlags(event, modifierFlags);
-  event.tangentialPressure = 0.0;
-  event.twist = 0;
-  event.isPrimary = true;
-
-  return event;
+  UpdateActiveTouchWithUITouch(activeTouch, uiTouch, rootComponentView, rootViewOriginOffset);
+  return activeTouch;
 }
 
 static BOOL AllTouchesAreCancelledOrEnded(NSSet<UITouch *> *touches)
@@ -435,28 +112,6 @@ static BOOL AnyTouchesChanged(NSSet<UITouch *> *touches)
   return NO;
 }
 
-static BOOL IsViewListeningToEvent(RCTReactTaggedView *taggedView, ViewEvents::Offset eventType)
-{
-  UIView *view = taggedView.view;
-  if (view && [view.class conformsToProtocol:@protocol(RCTComponentViewProtocol)]) {
-    auto props = ((id<RCTComponentViewProtocol>)view).props;
-    if (SharedViewProps viewProps = std::dynamic_pointer_cast<ViewProps const>(props)) {
-      return viewProps->events[eventType];
-    }
-  }
-  return NO;
-}
-
-static BOOL IsAnyViewInPathListeningToEvent(NSOrderedSet<RCTReactTaggedView *> *viewPath, ViewEvents::Offset eventType)
-{
-  for (RCTReactTaggedView *taggedView in viewPath) {
-    if (IsViewListeningToEvent(taggedView, eventType)) {
-      return YES;
-    }
-  }
-  return NO;
-}
-
 /**
  * Surprisingly, `__unsafe_unretained id` pointers are not regular pointers
  * and `std::hash<>` cannot hash them.
@@ -482,13 +137,9 @@ struct PointerHasher {
    * We hold the view weakly to prevent a retain cycle.
    */
   __weak UIView *_rootComponentView;
-  IdentifierPool<11> _identifierPool;
+  RCTIdentifierPool<11> _identifierPool;
 
-#if !TARGET_OS_TV
-  UIHoverGestureRecognizer *_hoverRecognizer API_AVAILABLE(ios(13.0));
-#endif
-  NSMutableDictionary<NSNumber *, NSOrderedSet<RCTReactTaggedView *> *> *_currentlyHoveredViewsPerPointer;
-  int _primaryTouchPointerId;
+  RCTSurfacePointerHandler *_pointerHandler;
 }
 
 - (instancetype)init
@@ -504,11 +155,9 @@ struct PointerHasher {
 
     self.delegate = self;
 
-#if !TARGET_OS_TV
-    _hoverRecognizer = nil;
-#endif
-    _currentlyHoveredViewsPerPointer = [[NSMutableDictionary alloc] init];
-    _primaryTouchPointerId = -1;
+    if (RCTGetDispatchW3CPointerEvents()) {
+      _pointerHandler = [[RCTSurfacePointerHandler alloc] init];
+    }
   }
 
   return self;
@@ -523,14 +172,9 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
   [view addGestureRecognizer:self];
   _rootComponentView = view;
 
-#if !TARGET_OS_TV
-  if (RCTGetDispatchW3CPointerEvents()) {
-    if (@available(iOS 13.0, *)) {
-      _hoverRecognizer = [[UIHoverGestureRecognizer alloc] initWithTarget:self action:@selector(hovering:)];
-      [view addGestureRecognizer:_hoverRecognizer];
-    }
+  if (_pointerHandler != nil) {
+    [_pointerHandler attachToView:view];
   }
-#endif
 }
 
 - (void)detachFromView:(UIView *)view
@@ -541,68 +185,30 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
   [view removeGestureRecognizer:self];
   _rootComponentView = nil;
 
-#if !TARGET_OS_TV
-  if (_hoverRecognizer != nil) {
-    [view removeGestureRecognizer:_hoverRecognizer];
-    _hoverRecognizer = nil;
+  if (_pointerHandler != nil) {
+    [_pointerHandler detachFromView:view];
   }
-#endif
 }
 
-- (void)_registerTouches:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+- (void)_registerTouches:(NSSet<UITouch *> *)touches
 {
   for (UITouch *touch in touches) {
-    auto activeTouch = CreateTouchWithUITouch(touch, event, _rootComponentView, _viewOriginOffset);
-
-    if (@available(iOS 13.4, *)) {
-      switch (touch.type) {
-        case UITouchTypeIndirectPointer:
-          activeTouch.touch.identifier = kMousePointerId;
-          activeTouch.isPrimary = true;
-          break;
-        case UITouchTypePencil:
-          activeTouch.touch.identifier = kPencilPointerId;
-          activeTouch.isPrimary = true;
-          break;
-        default:
-          // use the identifier pool offset to ensure no conflicts between the reserved IDs and the
-          // touch IDs
-          activeTouch.touch.identifier = _identifierPool.dequeue() + kTouchIdentifierPoolOffset;
-          if (_primaryTouchPointerId == -1) {
-            _primaryTouchPointerId = activeTouch.touch.identifier;
-            activeTouch.isPrimary = true;
-          }
-          break;
-      }
-    } else {
-      activeTouch.touch.identifier = _identifierPool.dequeue();
-      if (_primaryTouchPointerId == -1) {
-        _primaryTouchPointerId = activeTouch.touch.identifier;
-        activeTouch.isPrimary = true;
-      }
-    }
-
-    // If the pointer has not been marked as hovering over views before the touch started, we register
-    // that the activeTouch should not maintain its hovered state once the pointer has been lifted.
-    auto currentlyHoveredViews = [_currentlyHoveredViewsPerPointer objectForKey:@(activeTouch.touch.identifier)];
-    if (currentlyHoveredViews == nil || [currentlyHoveredViews count] == 0) {
-      activeTouch.shouldLeaveWhenReleased = YES;
-    }
-
+    auto activeTouch = CreateTouchWithUITouch(touch, _rootComponentView, _viewOriginOffset);
+    activeTouch.touch.identifier = _identifierPool.dequeue();
     _activeTouches.emplace(touch, activeTouch);
   }
 }
 
-- (void)_updateTouches:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+- (void)_updateTouches:(NSSet<UITouch *> *)touches
 {
   for (UITouch *touch in touches) {
     auto iterator = _activeTouches.find(touch);
-    assert(iterator != _activeTouches.end() && "Inconsistency between local and UIKit touch registries");
+    RCTAssert(iterator != _activeTouches.end(), @"Inconsistency between local and UIKit touch registries");
     if (iterator == _activeTouches.end()) {
       continue;
     }
 
-    UpdateActiveTouchWithUITouch(iterator->second, touch, event, _rootComponentView, _viewOriginOffset);
+    UpdateActiveTouchWithUITouch(iterator->second, touch, _rootComponentView, _viewOriginOffset);
   }
 }
 
@@ -610,30 +216,12 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   for (UITouch *touch in touches) {
     auto iterator = _activeTouches.find(touch);
-    assert(iterator != _activeTouches.end() && "Inconsistency between local and UIKit touch registries");
+    RCTAssert(iterator != _activeTouches.end(), @"Inconsistency between local and UIKit touch registries");
     if (iterator == _activeTouches.end()) {
       continue;
     }
     auto &activeTouch = iterator->second;
-
-    if (activeTouch.touch.identifier == _primaryTouchPointerId) {
-      _primaryTouchPointerId = -1;
-    }
-
-    if (@available(iOS 13.4, *)) {
-      // only need to enqueue if the touch type isn't one with a reserved identifier
-      switch (touch.type) {
-        case UITouchTypeIndirectPointer:
-        case UITouchTypePencil:
-          break;
-        default:
-          // since the touch's identifier has been offset we need to re-normalize it to 0-based
-          // which is what the identifier pool expects
-          _identifierPool.enqueue(activeTouch.touch.identifier - kTouchIdentifierPoolOffset);
-      }
-    } else {
-      _identifierPool.enqueue(activeTouch.touch.identifier);
-    }
+    _identifierPool.enqueue(activeTouch.touch.identifier);
     _activeTouches.erase(touch);
   }
 }
@@ -645,7 +233,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 
   for (UITouch *touch in touches) {
     auto iterator = _activeTouches.find(touch);
-    assert(iterator != _activeTouches.end() && "Inconsistency between local and UIKit touch registries");
+    RCTAssert(iterator != _activeTouches.end(), @"Inconsistency between local and UIKit touch registries");
     if (iterator == _activeTouches.end()) {
       continue;
     }
@@ -670,48 +258,6 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
     changedActiveTouches.insert(activeTouch);
     event.changedTouches.insert(activeTouch.touch);
     uniqueEventEmitters.insert(activeTouch.eventEmitter);
-
-    // emit w3c pointer events
-    if (RCTGetDispatchW3CPointerEvents()) {
-      PointerEvent pointerEvent = CreatePointerEventFromActiveTouch(activeTouch, eventType);
-      if ((eventType == RCTTouchEventTypeTouchEnd && activeTouch.shouldLeaveWhenReleased)) {
-        activeTouch.eventEmitter->onPointerUp(pointerEvent);
-#if !TARGET_OS_TV
-        [self handleIncomingPointerEvent:pointerEvent onView:nil];
-#endif
-      } else {
-        CGPoint clientLocation = CGPointMake(pointerEvent.clientPoint.x, pointerEvent.clientPoint.y);
-        UIView *targetView = FindClosestFabricManagedTouchableView([_rootComponentView hitTest:clientLocation
-                                                                                     withEvent:nil]);
-
-#if TARGET_OS_TV
-        NSOrderedSet<RCTReactTaggedView *> *eventPathViews = [[NSOrderedSet alloc] init];
-#else
-        NSOrderedSet<RCTReactTaggedView *> *eventPathViews = [self handleIncomingPointerEvent:pointerEvent
-                                                                                       onView:targetView];
-#endif
-        switch (eventType) {
-          case RCTTouchEventTypeTouchStart:
-            activeTouch.eventEmitter->onPointerDown(pointerEvent);
-            break;
-          case RCTTouchEventTypeTouchMove: {
-            bool hasMoveEventListeners =
-                IsAnyViewInPathListeningToEvent(eventPathViews, ViewEvents::Offset::PointerMove) ||
-                IsAnyViewInPathListeningToEvent(eventPathViews, ViewEvents::Offset::PointerMoveCapture);
-            if (hasMoveEventListeners) {
-              activeTouch.eventEmitter->onPointerMove(pointerEvent);
-            }
-            break;
-          }
-          case RCTTouchEventTypeTouchEnd:
-            activeTouch.eventEmitter->onPointerUp(pointerEvent);
-            break;
-          case RCTTouchEventTypeTouchCancel:
-            activeTouch.eventEmitter->onPointerCancel(pointerEvent);
-            break;
-        }
-      }
-    }
   }
 
   for (const auto &pair : _activeTouches) {
@@ -758,7 +304,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   [super touchesBegan:touches withEvent:event];
 
-  [self _registerTouches:touches withEvent:event];
+  [self _registerTouches:touches];
   [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchStart];
 
   if (self.state == UIGestureRecognizerStatePossible) {
@@ -772,7 +318,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   [super touchesMoved:touches withEvent:event];
 
-  [self _updateTouches:touches withEvent:event];
+  [self _updateTouches:touches];
   [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchMove];
 
   self.state = UIGestureRecognizerStateChanged;
@@ -782,7 +328,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   [super touchesEnded:touches withEvent:event];
 
-  [self _updateTouches:touches withEvent:event];
+  [self _updateTouches:touches];
   [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchEnd];
   [self _unregisterTouches:touches];
 
@@ -797,7 +343,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   [super touchesCancelled:touches withEvent:event];
 
-  [self _updateTouches:touches withEvent:event];
+  [self _updateTouches:touches];
   [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchCancel];
   [self _unregisterTouches:touches];
 
@@ -867,147 +413,4 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
   [self setEnabled:YES];
 }
 
-#if !TARGET_OS_TV
-- (void)hovering:(UIHoverGestureRecognizer *)recognizer API_AVAILABLE(ios(13.0))
-{
-  UIView *listenerView = recognizer.view;
-  CGPoint clientLocation = [recognizer locationInView:listenerView];
-  CGPoint screenLocation = [listenerView convertPoint:clientLocation
-                                    toCoordinateSpace:listenerView.window.screen.coordinateSpace];
-
-  UIView *targetView = [listenerView hitTest:clientLocation withEvent:nil];
-  targetView = FindClosestFabricManagedTouchableView(targetView);
-
-  CGPoint offsetLocation = [recognizer locationInView:targetView];
-
-  UIKeyModifierFlags modifierFlags;
-  if (@available(iOS 13.4, *)) {
-    modifierFlags = recognizer.modifierFlags;
-  } else {
-    modifierFlags = 0;
-  }
-
-  PointerEvent event =
-      CreatePointerEventFromIncompleteHoverData(clientLocation, screenLocation, offsetLocation, modifierFlags);
-
-  NSOrderedSet<RCTReactTaggedView *> *eventPathViews = [self handleIncomingPointerEvent:event onView:targetView];
-  SharedTouchEventEmitter eventEmitter = GetTouchEmitterFromView(targetView, offsetLocation);
-  bool hasMoveEventListeners = IsAnyViewInPathListeningToEvent(eventPathViews, ViewEvents::Offset::PointerMove) ||
-      IsAnyViewInPathListeningToEvent(eventPathViews, ViewEvents::Offset::PointerMoveCapture);
-  if (eventEmitter != nil && hasMoveEventListeners) {
-    eventEmitter->onPointerMove(event);
-  }
-}
-
-/**
- * Private method which is used for tracking the location of pointer events to manage the entering/leaving events.
- * The primary idea is that a pointer's presence & movement is dicated by a variety of underlying events such as down,
- * move, and up — and they should all be treated the same when it comes to tracking the entering & leaving of pointers
- * to views. This method accomplishes that by recieving the pointer event, the target view (can be null in cases when
- * the event indicates that the pointer has left the screen entirely), and a block/callback where the underlying event
- * should be fired.
- */
-- (NSOrderedSet<RCTReactTaggedView *> *)handleIncomingPointerEvent:(PointerEvent)event
-                                                            onView:(nullable UIView *)targetView
-{
-  int pointerId = event.pointerId;
-  CGPoint clientLocation = CGPointMake(event.clientPoint.x, event.clientPoint.y);
-
-  NSOrderedSet<RCTReactTaggedView *> *currentlyHoveredViews =
-      [_currentlyHoveredViewsPerPointer objectForKey:@(pointerId)];
-  if (currentlyHoveredViews == nil) {
-    currentlyHoveredViews = [NSOrderedSet orderedSet];
-  }
-
-  RCTReactTaggedView *targetTaggedView = [RCTReactTaggedView wrap:targetView];
-  RCTReactTaggedView *prevTargetTaggedView = [currentlyHoveredViews firstObject];
-  UIView *prevTargetView = prevTargetTaggedView.view;
-
-  NSOrderedSet<RCTReactTaggedView *> *eventPathViews = GetTouchableViewsInPathToRoot(targetView);
-
-  // Out
-  if (prevTargetView != nil && prevTargetTaggedView.tag != targetTaggedView.tag) {
-    BOOL shouldEmitOutEvent = IsAnyViewInPathListeningToEvent(currentlyHoveredViews, ViewEvents::Offset::PointerOut);
-    SharedTouchEventEmitter eventEmitter =
-        GetTouchEmitterFromView(prevTargetView, [_rootComponentView convertPoint:clientLocation toView:prevTargetView]);
-    if (shouldEmitOutEvent && eventEmitter != nil) {
-      eventEmitter->onPointerOut(event);
-    }
-  }
-
-  // Leaving
-
-  // pointerleave events need to be emited from the deepest target to the root but
-  // we also need to efficiently keep track of if a view has a parent which is listening to the leave events,
-  // so we first iterate from the root to the target, collecting the views which need events fired for, of which
-  // we reverse iterate (now from target to root), actually emitting the events.
-  NSMutableOrderedSet<UIView *> *viewsToEmitLeaveEventsTo = [NSMutableOrderedSet orderedSet];
-
-  BOOL hasParentLeaveListener = NO;
-  for (RCTReactTaggedView *taggedView in [currentlyHoveredViews reverseObjectEnumerator]) {
-    UIView *componentView = taggedView.view;
-
-    BOOL shouldEmitEvent = componentView != nil &&
-        (hasParentLeaveListener || IsViewListeningToEvent(taggedView, ViewEvents::Offset::PointerLeave));
-
-    if (shouldEmitEvent && ![eventPathViews containsObject:taggedView]) {
-      [viewsToEmitLeaveEventsTo addObject:componentView];
-    }
-
-    if (shouldEmitEvent && !hasParentLeaveListener) {
-      hasParentLeaveListener = YES;
-    }
-  }
-
-  for (UIView *componentView in [viewsToEmitLeaveEventsTo reverseObjectEnumerator]) {
-    SharedTouchEventEmitter eventEmitter =
-        GetTouchEmitterFromView(componentView, [_rootComponentView convertPoint:clientLocation toView:componentView]);
-    if (eventEmitter != nil) {
-      eventEmitter->onPointerLeave(event);
-    }
-  }
-
-  // Over
-  if (targetView != nil && prevTargetTaggedView.tag != targetTaggedView.tag) {
-    BOOL shouldEmitOverEvent = IsAnyViewInPathListeningToEvent(eventPathViews, ViewEvents::Offset::PointerOver);
-    SharedTouchEventEmitter eventEmitter =
-        GetTouchEmitterFromView(targetView, [_rootComponentView convertPoint:clientLocation toView:targetView]);
-    if (shouldEmitOverEvent && eventEmitter != nil) {
-      eventEmitter->onPointerOver(event);
-    }
-  }
-
-  // Entering
-
-  // We only want to emit events to JS if there is a view that is currently listening to said event
-  // so we only send those event to the JS side if the element which has been entered is itself listening,
-  // or if one of its parents is listening in case those listeners care about the capturing phase. Adding the ability
-  // for native to distingusih between capturing listeners and not could be an optimization to futher reduce the number
-  // of events we send to JS
-  BOOL hasParentEnterListener = NO;
-  for (RCTReactTaggedView *taggedView in [eventPathViews reverseObjectEnumerator]) {
-    UIView *componentView = taggedView.view;
-
-    BOOL shouldEmitEvent = componentView != nil &&
-        (hasParentEnterListener || IsViewListeningToEvent(taggedView, ViewEvents::Offset::PointerEnter));
-
-    if (shouldEmitEvent && ![currentlyHoveredViews containsObject:taggedView]) {
-      SharedTouchEventEmitter eventEmitter =
-          GetTouchEmitterFromView(componentView, [_rootComponentView convertPoint:clientLocation toView:componentView]);
-      if (eventEmitter != nil) {
-        eventEmitter->onPointerEnter(event);
-      }
-    }
-
-    if (shouldEmitEvent && !hasParentEnterListener) {
-      hasParentEnterListener = YES;
-    }
-  }
-
-  [_currentlyHoveredViewsPerPointer setObject:eventPathViews forKey:@(pointerId)];
-
-  return eventPathViews;
-}
-#endif
-
 @end