react-native-tvos 0.69.8-2 → 0.71.7-0rc0

package/React/Fabric/RCTSurfaceTouchHandler.mm

@@ -7,9 +7,9 @@
 
 #import "RCTSurfaceTouchHandler.h"
 
+#import <React/RCTReactTaggedView.h>
 #import <React/RCTUtils.h>
 #import <React/RCTViewComponentView.h>
-#import <UIKit/UIGestureRecognizerSubclass.h>
 
 #import "RCTConversions.h"
 #import "RCTTouchableComponentViewProtocol.h"
@@ -63,6 +63,47 @@ struct ActiveTouch {
    */
   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.
    */
@@ -83,15 +124,105 @@ 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)
 {
   CGPoint offsetPoint = [uiTouch locationInView:activeTouch.componentView];
-  CGPoint screenPoint = [uiTouch locationInView:uiTouch.window];
   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);
@@ -105,9 +236,29 @@ static void UpdateActiveTouchWithUITouch(
   }
 
   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, UIView *rootComponentView, CGPoint rootViewOriginOffset)
+static ActiveTouch
+CreateTouchWithUITouch(UITouch *uiTouch, UIEvent *uiEvent, UIView *rootComponentView, CGPoint rootViewOriginOffset)
 {
   ActiveTouch activeTouch = {};
 
@@ -123,8 +274,7 @@ static ActiveTouch CreateTouchWithUITouch(UITouch *uiTouch, UIView *rootComponen
     }
     componentView = componentView.superview;
   }
-
-  UpdateActiveTouchWithUITouch(activeTouch, uiTouch, rootComponentView, rootViewOriginOffset);
+  UpdateActiveTouchWithUITouch(activeTouch, uiTouch, uiEvent, rootComponentView, rootViewOriginOffset);
   return activeTouch;
 }
 
@@ -139,12 +289,12 @@ static UIView *FindClosestFabricManagedTouchableView(UIView *componentView)
   return nil;
 }
 
-static NSOrderedSet *GetTouchableViewsInPathToRoot(UIView *componentView)
+static NSOrderedSet<RCTReactTaggedView *> *GetTouchableViewsInPathToRoot(UIView *componentView)
 {
   NSMutableOrderedSet *results = [NSMutableOrderedSet orderedSet];
   do {
     if ([componentView respondsToSelector:@selector(touchEventEmitterAtPoint:)]) {
-      [results addObject:componentView];
+      [results addObject:[RCTReactTaggedView wrap:componentView]];
     }
     componentView = componentView.superview;
   } while (componentView);
@@ -171,33 +321,97 @@ static const char *PointerTypeCStringFromUITouchType(UITouchType type)
   }
 }
 
-static PointerEvent CreatePointerEventFromActiveTouch(ActiveTouch activeTouch)
+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.pressure = touch.force;
   event.pointerType = PointerTypeCStringFromUITouchType(activeTouch.touchType);
   event.clientPoint = touch.pagePoint;
-  event.target = touch.target;
-  event.timestamp = touch.timestamp;
+  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(UIView *view, CGPoint clientLocation, NSTimeInterval timestamp)
+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 = 0;
+  event.pointerId = kMousePointerId;
   event.pressure = 0.0;
   event.pointerType = "mouse";
   event.clientPoint = RCTPointFromCGPoint(clientLocation);
-  event.target = (Tag)view.tag;
-  event.timestamp = timestamp;
+  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;
 }
 
@@ -221,6 +435,28 @@ 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.
@@ -251,7 +487,8 @@ struct PointerHasher {
 #if !TARGET_OS_TV
   UIHoverGestureRecognizer *_hoverRecognizer API_AVAILABLE(ios(13.0));
 #endif
-  NSOrderedSet *_currentlyHoveredViews;
+  NSMutableDictionary<NSNumber *, NSOrderedSet<RCTReactTaggedView *> *> *_currentlyHoveredViewsPerPointer;
+  int _primaryTouchPointerId;
 }
 
 - (instancetype)init
@@ -270,7 +507,8 @@ struct PointerHasher {
 #if !TARGET_OS_TV
     _hoverRecognizer = nil;
 #endif
-    _currentlyHoveredViews = [NSOrderedSet orderedSet];
+    _currentlyHoveredViewsPerPointer = [[NSMutableDictionary alloc] init];
+    _primaryTouchPointerId = -1;
   }
 
   return self;
@@ -311,16 +549,51 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 #endif
 }
 
-- (void)_registerTouches:(NSSet<UITouch *> *)touches
+- (void)_registerTouches:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
   for (UITouch *touch in touches) {
-    auto activeTouch = CreateTouchWithUITouch(touch, _rootComponentView, _viewOriginOffset);
-    activeTouch.touch.identifier = _identifierPool.dequeue();
+    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;
+    }
+
     _activeTouches.emplace(touch, activeTouch);
   }
 }
 
-- (void)_updateTouches:(NSSet<UITouch *> *)touches
+- (void)_updateTouches:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
   for (UITouch *touch in touches) {
     auto iterator = _activeTouches.find(touch);
@@ -329,7 +602,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
       continue;
     }
 
-    UpdateActiveTouchWithUITouch(iterator->second, touch, _rootComponentView, _viewOriginOffset);
+    UpdateActiveTouchWithUITouch(iterator->second, touch, event, _rootComponentView, _viewOriginOffset);
   }
 }
 
@@ -342,7 +615,25 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
       continue;
     }
     auto &activeTouch = iterator->second;
-    _identifierPool.enqueue(activeTouch.touch.identifier);
+
+    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);
+    }
     _activeTouches.erase(touch);
   }
 }
@@ -382,20 +673,43 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 
     // emit w3c pointer events
     if (RCTGetDispatchW3CPointerEvents()) {
-      PointerEvent pointerEvent = CreatePointerEventFromActiveTouch(activeTouch);
-      switch (eventType) {
-        case RCTTouchEventTypeTouchStart:
-          activeTouch.eventEmitter->onPointerDown(pointerEvent);
-          break;
-        case RCTTouchEventTypeTouchMove:
-          activeTouch.eventEmitter->onPointerMove2(pointerEvent);
-          break;
-        case RCTTouchEventTypeTouchEnd:
-          activeTouch.eventEmitter->onPointerUp(pointerEvent);
-          break;
-        case RCTTouchEventTypeTouchCancel:
-          activeTouch.eventEmitter->onPointerCancel(pointerEvent);
-          break;
+      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;
+        }
       }
     }
   }
@@ -444,7 +758,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   [super touchesBegan:touches withEvent:event];
 
-  [self _registerTouches:touches];
+  [self _registerTouches:touches withEvent:event];
   [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchStart];
 
   if (self.state == UIGestureRecognizerStatePossible) {
@@ -458,7 +772,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   [super touchesMoved:touches withEvent:event];
 
-  [self _updateTouches:touches];
+  [self _updateTouches:touches withEvent:event];
   [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchMove];
 
   self.state = UIGestureRecognizerStateChanged;
@@ -468,7 +782,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   [super touchesEnded:touches withEvent:event];
 
-  [self _updateTouches:touches];
+  [self _updateTouches:touches withEvent:event];
   [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchEnd];
   [self _unregisterTouches:touches];
 
@@ -483,7 +797,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   [super touchesCancelled:touches withEvent:event];
 
-  [self _updateTouches:touches];
+  [self _updateTouches:touches withEvent:event];
   [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchCancel];
   [self _unregisterTouches:touches];
 
@@ -558,41 +872,141 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   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);
 
-  NSOrderedSet *eventPathViews = GetTouchableViewsInPathToRoot(targetView);
+  CGPoint offsetLocation = [recognizer locationInView:targetView];
 
-  NSTimeInterval timestamp = CACurrentMediaTime();
+  UIKeyModifierFlags modifierFlags;
+  if (@available(iOS 13.4, *)) {
+    modifierFlags = recognizer.modifierFlags;
+  } else {
+    modifierFlags = 0;
+  }
 
-  // Entering
-  // root -> child
-  for (UIView *componentView in [eventPathViews reverseObjectEnumerator]) {
-    if (![_currentlyHoveredViews containsObject:componentView]) {
-      SharedTouchEventEmitter eventEmitter =
-          GetTouchEmitterFromView(componentView, [recognizer locationInView:componentView]);
-      if (eventEmitter != nil) {
-        PointerEvent event = CreatePointerEventFromIncompleteHoverData(componentView, clientLocation, timestamp);
-        eventEmitter->onPointerEnter2(event);
-      }
+  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
-  // child -> root
-  for (UIView *componentView in _currentlyHoveredViews) {
-    if (![eventPathViews containsObject:componentView]) {
+
+  // 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, [recognizer locationInView:componentView]);
+          GetTouchEmitterFromView(componentView, [_rootComponentView convertPoint:clientLocation toView:componentView]);
       if (eventEmitter != nil) {
-        PointerEvent event = CreatePointerEventFromIncompleteHoverData(componentView, clientLocation, timestamp);
-        eventEmitter->onPointerLeave2(event);
+        eventEmitter->onPointerEnter(event);
       }
     }
+
+    if (shouldEmitEvent && !hasParentEnterListener) {
+      hasParentEnterListener = YES;
+    }
   }
 
-  _currentlyHoveredViews = eventPathViews;
+  [_currentlyHoveredViewsPerPointer setObject:eventPathViews forKey:@(pointerId)];
+
+  return eventPathViews;
 }
 #endif