Refactor hover tracking logic to the shared C++ renderer

[vincentriemer]

Summary:
Changelog: [Internal] - Refactor hover tracking logic to the shared c++ renderer

This diff refactors our hover tracking logic out of the platform (in this case only iOS, integrating Android is going to require extra work due to their pointer events being untyped) and puts it into the event intercepting infra in Fabric's C++ core. This is a big-ish diff so I'm going to try my best to use this summary to guide you through the changes.

To begin with — the changes inside RCTSurfacePointerHandler.mm are mostly about removing the existing hover tracking logic. The logic of the hover tracking is largely the same between the objective-c and c++ implementations with minor tweaks in order to be a better citizen when it comes to storing node references. One small "addition" to this file is explicitly firing a pointerleave event from the iOS layer when we detect that the pointer has left the app entirely because the C++ would otherwise not know when the pointer leaves the app. We don't need to include a special case for pointerenter because we can derive that in C++ from the first pointermove event that gets sent once the pointer re-enters the app's root view.

Next I think it makes most sense to continue onto the PointerEventsProcessor.h/mm which is the central class we're working in. One small change is adding a flag to the ActivePointer struct (shouldLeaveWhenReleased) which we will set during ActivePointer registration — setting to false if the pointer in question exists in the (also) newly added previousHoverTrackersPerPointer_ registry. This logic is primarily used for knowing later when the pointer is released and whether we should emit the synthetic leave/out event on release. If the pointer existed in previousHoverTrackersPerPointer_ before the ActivePointer registration that implies that the pointer is capable of hovering to some degree and we should not emit those leave/out events yet.

The real meat & potatoes of this diff is the handleIncomingPointerEventOnNode method which matches the handleIncomingPointerEvent method we removed from RCTSurfacePointerHandler.mm. This method derives the enter/leave/over/out pointer events by comparing the current event's target path (list of nodes from the root node to the target node of the event) to the previously recorded event target path. The representation of this event path is through the new PointerHoverTracker class which stores a pointer to just the root node and the target node as we can recreate the entire event path from these.

For over/out events all that matters is when the deepest-most target changes which is checked in handleIncomingPointerEventOnNode by leveraging PointerHoverTracker's hasSameTarget method. For enter/leave events we need to fire discrete events for every node in the path which has either been removed or added, so the diffEventPath method was introduced on PointerHoverTracker to provide that.

Differential Revision: D51317492

[facebook-github-bot]

This pull request was exported from Phabricator. Differential Revision: D51317492

[analysis-bot]

Platform	Engine	Arch	Size (bytes)	Diff
android	hermes	arm64-v8a	17,666,170	+20,474
android	hermes	armeabi-v7a	n/a	--
android	hermes	x86	n/a	--
android	hermes	x86_64	n/a	--
android	jsc	arm64-v8a	21,054,189	+20,471
android	jsc	armeabi-v7a	n/a	--
android	jsc	x86	n/a	--
android	jsc	x86_64	n/a	--

Base commit: fa89dd6
Branch: main

[github-actions]

This pull request was successfully merged by @vincentriemer in 72b876a.

^{When will my fix make it into a release? | Upcoming Releases}