Send unix timestamp for touch events instead of systemUptime

Summary:
We want to be able to instrument touch processing delays in JS, which does not have access to systemUptime; therefore we want a UNIX timestamp, which JS has access to and can compare to the touch time.

It only matters that there is relative consistency between multiple touch events in JS, which is still the case; so this should have no impact on product code.

Changelog: [Internal]

Reviewed By: sammy-SC

Differential Revision: D26705430

fbshipit-source-id: 2acd52ae5873a44edf1e0cb126a9a6c87203d8fa

Author: JoshuaGross

React/Base/RCTTouchHandler.m

@@ -8,6 +8,7 @@
 #import "RCTTouchHandler.h"
 
 #import <UIKit/UIGestureRecognizerSubclass.h>
+#import <UIKit/UIKit.h>
 
 #import "RCTAssert.h"
 #import "RCTBridge.h"
@@ -39,6 +40,10 @@ @implementation RCTTouchHandler {
 
   __weak UIView *_cachedRootView;
 
+  // See Touch.h and usage. This gives us a time-basis for a monotonic
+  // clock that acts like a timestamp of milliseconds elapsed since UNIX epoch.
+  NSTimeInterval _unixEpochBasisTime;
+
   uint16_t _coalescingKey;
 }
 
@@ -53,6 +58,9 @@ - (instancetype)initWithBridge:(RCTBridge *)bridge
     _reactTouches = [NSMutableArray new];
     _touchViews = [NSMutableArray new];
 
+    // Get a UNIX epoch basis time:
+    _unixEpochBasisTime = [[NSDate date] timeIntervalSince1970] - [NSProcessInfo processInfo].systemUptime;
+
     // `cancelsTouchesInView` and `delaysTouches*` are needed in order to be used as a top level
     // event delegated recognizer. Otherwise, lower-level components not built
     // using RCT, will fail to recognize gestures.
@@ -159,7 +167,7 @@ - (void)_updateReactTouchAtIndex:(NSInteger)touchIndex
   reactTouch[@"pageY"] = @(RCTSanitizeNaNValue(rootViewLocation.y, @"touchEvent.pageY"));
   reactTouch[@"locationX"] = @(RCTSanitizeNaNValue(touchViewLocation.x, @"touchEvent.locationX"));
   reactTouch[@"locationY"] = @(RCTSanitizeNaNValue(touchViewLocation.y, @"touchEvent.locationY"));
-  reactTouch[@"timestamp"] = @(nativeTouch.timestamp * 1000); // in ms, for JS
+  reactTouch[@"timestamp"] = @((_unixEpochBasisTime + nativeTouch.timestamp) * 1000); // in ms, for JS
 
   // TODO: force for a 'normal' touch is usually 1.0;
   // should we expose a `normalTouchForce` constant somewhere (which would

React/Fabric/RCTSurfaceTouchHandler.mm

@@ -10,6 +10,7 @@
 #import <React/RCTUtils.h>
 #import <React/RCTViewComponentView.h>
 #import <UIKit/UIGestureRecognizerSubclass.h>
+#import <UIKit/UIKit.h>
 
 #import "RCTConversions.h"
 #import "RCTTouchableComponentViewProtocol.h"
@@ -82,7 +83,8 @@ static void UpdateActiveTouchWithUITouch(
     ActiveTouch &activeTouch,
     UITouch *uiTouch,
     UIView *rootComponentView,
-    CGPoint rootViewOriginOffset)
+    CGPoint rootViewOriginOffset,
+    NSTimeInterval unixTimestampBasis)
 {
   CGPoint offsetPoint = [uiTouch locationInView:activeTouch.componentView];
   CGPoint screenPoint = [uiTouch locationInView:uiTouch.window];
@@ -93,14 +95,18 @@ static void UpdateActiveTouchWithUITouch(
   activeTouch.touch.screenPoint = RCTPointFromCGPoint(screenPoint);
   activeTouch.touch.pagePoint = RCTPointFromCGPoint(pagePoint);
 
-  activeTouch.touch.timestamp = uiTouch.timestamp;
+  activeTouch.touch.timestamp = unixTimestampBasis + uiTouch.timestamp;
 
   if (RCTForceTouchAvailable()) {
     activeTouch.touch.force = RCTZeroIfNaN(uiTouch.force / uiTouch.maximumPossibleForce);
   }
 }
 
-static ActiveTouch CreateTouchWithUITouch(UITouch *uiTouch, UIView *rootComponentView, CGPoint rootViewOriginOffset)
+static ActiveTouch CreateTouchWithUITouch(
+    UITouch *uiTouch,
+    UIView *rootComponentView,
+    CGPoint rootViewOriginOffset,
+    NSTimeInterval unixTimestampBasis)
 {
   ActiveTouch activeTouch = {};
 
@@ -117,7 +123,7 @@ static ActiveTouch CreateTouchWithUITouch(UITouch *uiTouch, UIView *rootComponen
     componentView = componentView.superview;
   }
 
-  UpdateActiveTouchWithUITouch(activeTouch, uiTouch, rootComponentView, rootViewOriginOffset);
+  UpdateActiveTouchWithUITouch(activeTouch, uiTouch, rootComponentView, rootViewOriginOffset, unixTimestampBasis);
   return activeTouch;
 }
 
@@ -167,6 +173,12 @@ @implementation RCTSurfaceTouchHandler {
    */
   __weak UIView *_rootComponentView;
   IdentifierPool<11> _identifierPool;
+
+  /*
+   * See Touch.h and usage. This gives us a time-basis for a monotonic
+   * clock that acts like a timestamp of milliseconds elapsed since UNIX epoch.
+   */
+  NSTimeInterval _unixEpochBasisTime;
 }
 
 - (instancetype)init
@@ -181,6 +193,8 @@ - (instancetype)init
     self.delaysTouchesEnded = NO;
 
     self.delegate = self;
+
+    _unixEpochBasisTime = [[NSDate date] timeIntervalSince1970] - [NSProcessInfo processInfo].systemUptime;
   }
 
   return self;
@@ -208,7 +222,7 @@ - (void)detachFromView:(UIView *)view
 - (void)_registerTouches:(NSSet<UITouch *> *)touches
 {
   for (UITouch *touch in touches) {
-    auto activeTouch = CreateTouchWithUITouch(touch, _rootComponentView, _viewOriginOffset);
+    auto activeTouch = CreateTouchWithUITouch(touch, _rootComponentView, _viewOriginOffset, _unixEpochBasisTime);
     activeTouch.touch.identifier = _identifierPool.dequeue();
     _activeTouches.emplace(touch, activeTouch);
   }
@@ -223,7 +237,7 @@ - (void)_updateTouches:(NSSet<UITouch *> *)touches
       continue;
     }
 
-    UpdateActiveTouchWithUITouch(iterator->second, touch, _rootComponentView, _viewOriginOffset);
+    UpdateActiveTouchWithUITouch(iterator->second, touch, _rootComponentView, _viewOriginOffset, _unixEpochBasisTime);
   }
 }
 

ReactCommon/react/renderer/components/view/Touch.h

@@ -52,7 +52,38 @@ struct Touch {
   Float force;
 
   /*
-   * The time in seconds when the touch occurred or when it was last mutated.
+   * The time in seconds (with fractional milliseconds) when the touch occurred
+   * or when it was last mutated.
+   *
+   * Whenever possible this should be computed as:
+   * 1. Pick MONO_CLOCK_NOW, a monotonic system clock. Generally, something like
+   * `systemUptimeMillis`.
+   * 2. BASIS_TIME = unix timestamp from unix epoch (ms) - MONO_CLOCK_NOW
+   * 3. Then assign timestamp = BASIS_TIME + MONO_CLOCK_NOW
+   *
+   * The effect should be UNIX timestamp from UNIX epoch, but as a monotonic
+   * clock (if you just assign to current system time, it can move backwards due
+   * to clock adjustements, leap seconds, etc etc). So the vast majority of the
+   * time it will look identical to current UNIX time, but there are some
+   * edge-cases where it can drift.
+   *
+   * If you are not able to use the scheme above for some reason, prefer to use
+   * a monotonic clock. This timestamp MUST be monotonic. Do NOT just pass along
+   * system time.
+   *
+   * The goal is to allow touch latency to be computed in JS. JS does not have
+   * access to something like `systemUptimeMillis`, it generally can only access
+   * the current system time. This *does* mean that the touch latency could be
+   * computed incorrectly in cases of clock drift, so you should only use this
+   * as telemetry to get a decent, but not totally perfect, idea of performance.
+   * Do not use this latency information for anything "mission critical". You
+   * can assume it's probably reasonably accurate 99% of the time.
+   *
+   * Note that we attempt to adhere to the spec of timestamp here:
+   * https://dom.spec.whatwg.org/#dom-event-timestamp
+   * Notably, since `global` is not a Window object in React Native, we have
+   * some flexibility in how we define the time origin:
+   * https://w3c.github.io/hr-time/#dfn-time-origin
    */
   Float timestamp;