@react-native-oh/react-native-harmony 0.72.10

package/Libraries/Utilities/BackHandler.harmony.js

@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// RNOH: This is a copy of the original Android file
+
+import NativeDeviceEventManager from 'react-native/Libraries/NativeModules/specs/NativeDeviceEventManager';
+import RCTDeviceEventEmitter from 'react-native/Libraries/EventEmitter/RCTDeviceEventEmitter';
+
+const DEVICE_BACK_EVENT = 'hardwareBackPress';
+
+type BackPressEventName = 'backPress' | 'hardwareBackPress';
+
+const _backPressSubscriptions = [];
+
+RCTDeviceEventEmitter.addListener(DEVICE_BACK_EVENT, function () {
+  for (let i = _backPressSubscriptions.length - 1; i >= 0; i--) {
+    if (_backPressSubscriptions[i]()) {
+      return;
+    }
+  }
+
+  BackHandler.exitApp();
+});
+
+/**
+ * Detect hardware button presses for back navigation.
+ *
+ * Android: Detect hardware back button presses, and programmatically invoke the default back button
+ * functionality to exit the app if there are no listeners or if none of the listeners return true.
+ *
+ * iOS: Not applicable.
+ *
+ * The event subscriptions are called in reverse order (i.e. last registered subscription first),
+ * and if one subscription returns true then subscriptions registered earlier will not be called.
+ *
+ * Example:
+ *
+ * ```javascript
+ * BackHandler.addEventListener('hardwareBackPress', function() {
+ *  // this.onMainScreen and this.goBack are just examples, you need to use your own implementation here
+ *  // Typically you would use the navigator here to go to the last state.
+ *
+ *  if (!this.onMainScreen()) {
+ *    this.goBack();
+ *    return true;
+ *  }
+ *  return false;
+ * });
+ * ```
+ */
+type TBackHandler = {|
+  +exitApp: () => void,
+  +addEventListener: (
+    eventName: BackPressEventName,
+    handler: () => ?boolean,
+  ) => {remove: () => void, ...},
+  +removeEventListener: (
+    eventName: BackPressEventName,
+    handler: () => ?boolean,
+  ) => void,
+|};
+const BackHandler: TBackHandler = {
+  exitApp: function (): void {
+    if (!NativeDeviceEventManager) {
+      return;
+    }
+
+    NativeDeviceEventManager.invokeDefaultBackPressHandler();
+  },
+
+  /**
+   * Adds an event handler. Supported events:
+   *
+   * - `hardwareBackPress`: Fires when the Android hardware back button is pressed.
+   */
+  addEventListener: function (
+    eventName: BackPressEventName,
+    handler: () => ?boolean,
+  ): {remove: () => void, ...} {
+    if (_backPressSubscriptions.indexOf(handler) === -1) {
+      _backPressSubscriptions.push(handler);
+    }
+    return {
+      remove: (): void => BackHandler.removeEventListener(eventName, handler),
+    };
+  },
+
+  /**
+   * Removes the event handler.
+   */
+  removeEventListener: function (
+    eventName: BackPressEventName,
+    handler: () => ?boolean,
+  ): void {
+    const index = _backPressSubscriptions.indexOf(handler);
+    if (index !== -1) {
+      _backPressSubscriptions.splice(index, 1);
+    }
+  },
+};
+
+module.exports = BackHandler;

package/Libraries/Utilities/NativePlatformConstantsHarmony.ts

@@ -0,0 +1,8 @@
+import { TurboModule, TurboModuleRegistry } from 'react-native';
+import { PlatformHarmonyConstants } from "./Platform";
+
+interface Spec extends TurboModule {
+  getConstants: () => PlatformHarmonyConstants;
+}
+
+export const NativePlatformConstantsHarmony = TurboModuleRegistry.getEnforcing<Spec>('PlatformConstants');

package/Libraries/Utilities/Platform.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+/**
+ * @see https://reactnative.dev/docs/platform-specific-code#content
+ */
+export type PlatformOSType =
+  | 'ios'
+  | 'android'
+  | 'macos'
+  | 'windows'
+  | 'web'
+  | "harmony" // RNOH: patch
+  | 'native';
+type PlatformConstants = {
+  isTesting: boolean;
+  reactNativeVersion: {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease?: number | null | undefined;
+  };
+};
+interface PlatformStatic {
+  isTV: boolean;
+  isTesting: boolean;
+  Version: number | string;
+  constants: PlatformConstants;
+
+  /**
+   * @see https://reactnative.dev/docs/platform-specific-code#content
+   */
+  select<T>(
+    specifics:
+      | ({ [platform in PlatformOSType]?: T } & { default: T; })
+      | { [platform in PlatformOSType]: T },
+  ): T;
+  select<T>(specifics: { [platform in PlatformOSType]?: T }): T | undefined;
+}
+
+interface PlatformIOSStatic extends PlatformStatic {
+  constants: PlatformConstants & {
+    forceTouchAvailable: boolean;
+    interfaceIdiom: string;
+    osVersion: string;
+    systemName: string;
+  };
+  OS: 'ios';
+  isPad: boolean;
+  isTV: boolean;
+  Version: string;
+}
+
+interface PlatformAndroidStatic extends PlatformStatic {
+  constants: PlatformConstants & {
+    Version: number;
+    Release: string;
+    Serial: string;
+    Fingerprint: string;
+    Model: string;
+    Brand: string;
+    Manufacturer: string;
+    ServerHost?: string | undefined;
+    uiMode: 'car' | 'desk' | 'normal' | 'tv' | 'watch' | 'unknown';
+  };
+  OS: 'android';
+  Version: number;
+}
+
+interface PlatformMacOSStatic extends PlatformStatic {
+  OS: 'macos';
+  Version: string;
+  constants: PlatformConstants & {
+    osVersion: string;
+  };
+}
+
+interface PlatformWindowsOSStatic extends PlatformStatic {
+  OS: 'windows';
+  Version: number;
+  constants: PlatformConstants & {
+    osVersion: number;
+  };
+}
+
+interface PlatformWebStatic extends PlatformStatic {
+  OS: 'web';
+}
+
+// begin RNOH: patch
+export type PlatformHarmonyConstants = PlatformConstants & {
+  deviceType: "default" | "phone" | "wearable" | "liteWearable" | "tablet" | "tv" | "car" | "smartVision";
+  osFullName: string;
+  Model: string;
+};
+
+export interface PlatformHarmonyStatic extends PlatformStatic {
+  OS: 'harmony';
+  constants: PlatformHarmonyConstants;
+}
+// end RNOH: patch
+
+export type Platform =
+  | PlatformIOSStatic
+  | PlatformAndroidStatic
+  | PlatformWindowsOSStatic
+  | PlatformMacOSStatic
+  | PlatformWebStatic
+  | PlatformHarmonyStatic; // RNOH: patch
+
+export const Platform: Platform;

package/Libraries/Utilities/Platform.harmony.ts

@@ -0,0 +1,33 @@
+import { NativePlatformConstantsHarmony } from "./NativePlatformConstantsHarmony";
+import type { PlatformHarmonyStatic, PlatformHarmonyConstants, PlatformOSType } from "./Platform";
+
+const Platform = {
+  __constants: undefined as undefined | PlatformHarmonyConstants,
+  OS: 'harmony' as const,
+  get constants() {
+    if (this.__constants == null) {
+      this.__constants = NativePlatformConstantsHarmony.getConstants();
+    }
+    return this.__constants;
+  },
+  get Version() {
+    return this.constants.osFullName;
+  },
+  get isPad() {
+    return this.constants.deviceType === 'tablet';
+  },
+  get isTV() {
+    return this.constants.deviceType === 'tv';
+  },
+  get isTesting() {
+    if (__DEV__) {
+      return this.constants.isTesting;
+    }
+    return false;
+  },
+  select<T>(spec: ({ [platform in PlatformOSType]?: T } & { default: T; }) | { [platform in PlatformOSType]: T }) {
+    return 'harmony' in spec ? spec.harmony : 'native' in spec ? spec.native : spec.default;
+  }
+};
+
+module.exports = Platform as PlatformHarmonyStatic;

package/Libraries/Utilities/createPerformanceLogger.harmony.js

@@ -0,0 +1,328 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+const Systrace = require('react-native/Libraries/Performance/Systrace'); // RNOH: patch
+const infoLog = require('react-native/Libraries/Utilities/infoLog'); // RNOH: patch
+
+export type Timespan = {
+  startTime: number,
+  endTime?: number,
+  totalTime?: number,
+  startExtras?: Extras,
+  endExtras?: Extras,
+};
+
+// Extra values should be serializable primitives
+export type ExtraValue = number | string | boolean;
+
+export type Extras = {[key: string]: ExtraValue};
+
+export interface IPerformanceLogger {
+  addTimespan(
+    key: string,
+    startTime: number,
+    endTime: number,
+    startExtras?: Extras,
+    endExtras?: Extras,
+  ): void;
+  append(logger: IPerformanceLogger): void;
+  clear(): void;
+  clearCompleted(): void;
+  close(): void;
+  currentTimestamp(): number;
+  getExtras(): $ReadOnly<{[key: string]: ?ExtraValue, ...}>;
+  getPoints(): $ReadOnly<{[key: string]: ?number, ...}>;
+  getPointExtras(): $ReadOnly<{[key: string]: ?Extras, ...}>;
+  getTimespans(): $ReadOnly<{[key: string]: ?Timespan, ...}>;
+  hasTimespan(key: string): boolean;
+  isClosed(): boolean;
+  logEverything(): void;
+  markPoint(key: string, timestamp?: number, extras?: Extras): void;
+  removeExtra(key: string): ?ExtraValue;
+  setExtra(key: string, value: ExtraValue): void;
+  startTimespan(key: string, timestamp?: number, extras?: Extras): void;
+  stopTimespan(key: string, timestamp?: number, extras?: Extras): void;
+}
+
+const _cookies: {[key: string]: number, ...} = {};
+
+const PRINT_TO_CONSOLE: false = false; // Type as false to prevent accidentally committing `true`;
+
+export const getCurrentTimestamp: () => number =
+  global.nativeQPLTimestamp ?? global.performance ? global.performance.now.bind(global.performance) : Date.now; // RNOH: patch
+
+class PerformanceLogger implements IPerformanceLogger {
+  _timespans: {[key: string]: ?Timespan} = {};
+  _extras: {[key: string]: ?ExtraValue} = {};
+  _points: {[key: string]: ?number} = {};
+  _pointExtras: {[key: string]: ?Extras, ...} = {};
+  _closed: boolean = false;
+
+  addTimespan(
+    key: string,
+    startTime: number,
+    endTime: number,
+    startExtras?: Extras,
+    endExtras?: Extras,
+  ) {
+    if (this._closed) {
+      if (PRINT_TO_CONSOLE && __DEV__) {
+        infoLog('PerformanceLogger: addTimespan - has closed ignoring: ', key);
+      }
+      return;
+    }
+    if (this._timespans[key]) {
+      if (PRINT_TO_CONSOLE && __DEV__) {
+        infoLog(
+          'PerformanceLogger: Attempting to add a timespan that already exists ',
+          key,
+        );
+      }
+      return;
+    }
+
+    this._timespans[key] = {
+      startTime,
+      endTime,
+      totalTime: endTime - (startTime || 0),
+      startExtras,
+      endExtras,
+    };
+  }
+
+  append(performanceLogger: IPerformanceLogger) {
+    this._timespans = {
+      ...performanceLogger.getTimespans(),
+      ...this._timespans,
+    };
+    this._extras = {...performanceLogger.getExtras(), ...this._extras};
+    this._points = {...performanceLogger.getPoints(), ...this._points};
+    this._pointExtras = {
+      ...performanceLogger.getPointExtras(),
+      ...this._pointExtras,
+    };
+  }
+
+  clear() {
+    this._timespans = {};
+    this._extras = {};
+    this._points = {};
+    if (PRINT_TO_CONSOLE) {
+      infoLog('PerformanceLogger.js', 'clear');
+    }
+  }
+
+  clearCompleted() {
+    for (const key in this._timespans) {
+      if (this._timespans[key]?.totalTime != null) {
+        delete this._timespans[key];
+      }
+    }
+    this._extras = {};
+    this._points = {};
+    if (PRINT_TO_CONSOLE) {
+      infoLog('PerformanceLogger.js', 'clearCompleted');
+    }
+  }
+
+  close() {
+    this._closed = true;
+  }
+
+  currentTimestamp(): number {
+    return getCurrentTimestamp();
+  }
+
+  getExtras(): {[key: string]: ?ExtraValue} {
+    return this._extras;
+  }
+
+  getPoints(): {[key: string]: ?number} {
+    return this._points;
+  }
+
+  getPointExtras(): {[key: string]: ?Extras} {
+    return this._pointExtras;
+  }
+
+  getTimespans(): {[key: string]: ?Timespan} {
+    return this._timespans;
+  }
+
+  hasTimespan(key: string): boolean {
+    return !!this._timespans[key];
+  }
+
+  isClosed(): boolean {
+    return this._closed;
+  }
+
+  logEverything() {
+    if (PRINT_TO_CONSOLE) {
+      // log timespans
+      for (const key in this._timespans) {
+        if (this._timespans[key]?.totalTime != null) {
+          infoLog(key + ': ' + this._timespans[key].totalTime + 'ms');
+        }
+      }
+
+      // log extras
+      infoLog(this._extras);
+
+      // log points
+      for (const key in this._points) {
+        if (this._points[key] != null) {
+          infoLog(key + ': ' + this._points[key] + 'ms');
+        }
+      }
+    }
+  }
+
+  markPoint(
+    key: string,
+    timestamp?: number = getCurrentTimestamp(),
+    extras?: Extras,
+  ) {
+    if (this._closed) {
+      if (PRINT_TO_CONSOLE && __DEV__) {
+        infoLog('PerformanceLogger: markPoint - has closed ignoring: ', key);
+      }
+      return;
+    }
+    if (this._points[key] != null) {
+      if (PRINT_TO_CONSOLE && __DEV__) {
+        infoLog(
+          'PerformanceLogger: Attempting to mark a point that has been already logged ',
+          key,
+        );
+      }
+      return;
+    }
+    this._points[key] = timestamp;
+    if (extras) {
+      this._pointExtras[key] = extras;
+    }
+  }
+
+  removeExtra(key: string): ?ExtraValue {
+    const value = this._extras[key];
+    delete this._extras[key];
+    return value;
+  }
+
+  setExtra(key: string, value: ExtraValue) {
+    if (this._closed) {
+      if (PRINT_TO_CONSOLE && __DEV__) {
+        infoLog('PerformanceLogger: setExtra - has closed ignoring: ', key);
+      }
+      return;
+    }
+
+    if (this._extras.hasOwnProperty(key)) {
+      if (PRINT_TO_CONSOLE && __DEV__) {
+        infoLog(
+          'PerformanceLogger: Attempting to set an extra that already exists ',
+          {key, currentValue: this._extras[key], attemptedValue: value},
+        );
+      }
+      return;
+    }
+    this._extras[key] = value;
+  }
+
+  startTimespan(
+    key: string,
+    timestamp?: number = getCurrentTimestamp(),
+    extras?: Extras,
+  ) {
+    if (this._closed) {
+      if (PRINT_TO_CONSOLE && __DEV__) {
+        infoLog(
+          'PerformanceLogger: startTimespan - has closed ignoring: ',
+          key,
+        );
+      }
+      return;
+    }
+
+    if (this._timespans[key]) {
+      if (PRINT_TO_CONSOLE && __DEV__) {
+        infoLog(
+          'PerformanceLogger: Attempting to start a timespan that already exists ',
+          key,
+        );
+      }
+      return;
+    }
+
+    this._timespans[key] = {
+      startTime: timestamp,
+      startExtras: extras,
+    };
+    _cookies[key] = Systrace.beginAsyncEvent(key);
+    if (PRINT_TO_CONSOLE) {
+      infoLog('PerformanceLogger.js', 'start: ' + key);
+    }
+  }
+
+  stopTimespan(
+    key: string,
+    timestamp?: number = getCurrentTimestamp(),
+    extras?: Extras,
+  ) {
+    if (this._closed) {
+      if (PRINT_TO_CONSOLE && __DEV__) {
+        infoLog('PerformanceLogger: stopTimespan - has closed ignoring: ', key);
+      }
+      return;
+    }
+
+    const timespan = this._timespans[key];
+    if (!timespan || timespan.startTime == null) {
+      if (PRINT_TO_CONSOLE && __DEV__) {
+        infoLog(
+          'PerformanceLogger: Attempting to end a timespan that has not started ',
+          key,
+        );
+      }
+      return;
+    }
+    if (timespan.endTime != null) {
+      if (PRINT_TO_CONSOLE && __DEV__) {
+        infoLog(
+          'PerformanceLogger: Attempting to end a timespan that has already ended ',
+          key,
+        );
+      }
+      return;
+    }
+
+    timespan.endExtras = extras;
+    timespan.endTime = timestamp;
+    timespan.totalTime = timespan.endTime - (timespan.startTime || 0);
+    if (PRINT_TO_CONSOLE) {
+      infoLog('PerformanceLogger.js', 'end: ' + key);
+    }
+
+    if (_cookies[key] != null) {
+      Systrace.endAsyncEvent(key, _cookies[key]);
+      delete _cookies[key];
+    }
+  }
+}
+
+/**
+ * This function creates performance loggers that can be used to collect and log
+ * various performance data such as timespans, points and extras.
+ * The loggers need to have minimal overhead since they're used in production.
+ */
+export default function createPerformanceLogger(): IPerformanceLogger {
+  return new PerformanceLogger();
+}