Description

Replaces the bare native {now, timeOrigin} object with a spec-shaped implementation of hr-time, User Timing Level 3 and the performance timeline with PerformanceObserver. performance, Performance, PerformanceEntry, PerformanceMark, PerformanceMeasure, PerformanceObserver and PerformanceObserverEntryList are globals in main and worker isolates alike, with Performance extends EventTarget and WebIDL-shaped descriptors/brands.

Stacked on #2000 — review only the last two commits.

Architecture

• All spec logic lives in the internal/performance.js builtin. The native side hands it exactly two things — binding.now() (double ms, monotonic) and binding.timeOrigin (wall-clock ms) — so the file is shared verbatim with the iOS runtime (it differs from iOS's copy by two comment lines only, both naming the Android init entry point).
• tns::Performance native shim (Performance.h/.cpp) runs post-context in PrepareV8Runtime, after Events::Init/ErrorEvents::Init/StructuredClone::Init. Performance::NowMillis(isolate) is the single native clock hook: future requestAnimationFrame work must read the clock through it (V8 platform monotonic clock, CLOCK_MONOTONIC base) so every JS-visible timestamp shares performance.timeOrigin.
• Per-worker time origins: origins stay captured per Runtime right after Isolate::New (members renamed to m_timeOriginMonotonic/m_timeOriginRealtimeMs, with public PerformanceNowMillis()/TimeOriginMillis() accessors replacing the private PerformanceNowCallback), so each worker keeps its own timeOrigin — asserted by the worker specs.
• performance.now() keeps full double precision (no coarsening, Node's choice).
• New primordials: SymbolToStringTag, NumberIsFinite, ArrayPrototypeSort (plus the matching Number.isFinite entry in the ESLint capturedStatics rule).

Frame callbacks are the first consumer (2nd commit)

The clock hook exists so JS-visible timestamps share one base, so this PR wires up the runtime's existing frame callbacks rather than leaving the hook unused.

• Two-argument contract: __postFrameCallback now calls back with (frameTimeNanos, performanceMillis). The first argument is unchanged — raw CLOCK_MONOTONIC nanos, which @nativescript/core divides by 1e6 — so this is additive and nothing breaks; the second is the same instant on the performance timeline, comparable with performance.now(). Core can migrate to the second argument at its own pace.
• Exact, not resampled: Choreographer stamps frames on the very clock the time origin is captured on, so Performance::MonotonicNanosToTimelineMillis() just subtracts the new Runtime::TimeOriginMonotonicMillis(). Verified on device: the origin implied by the two arguments matches the one implied by (System.nanoTime(), performance.now()).
• The whole minSdk range is covered now. AChoreographer only exists from API 24, so on API 21–23 __postFrameCallback existed but silently never fired. The machinery moves out of CallbackHandlers into FrameCallbacks.{h,cpp}, and API 21–23 goes through android.view.Choreographer via a new com.tns.FrameCallbacks (same entry, same two arguments, per-thread so workers schedule against their own looper).
• Cleanups carried by the move: entries live behind unique_ptr so both implementations can hand the platform a stable pointer; isolate teardown no longer erases while iterating; and the pre-API-29 AChoreographer entry point's frame time is widened to 64 bits, which it is not on the 32-bit ABIs (the reason postFrameCallback64 exists).
• Debug runtimes expose __setFrameCallbackImpl (absent from release) so the Java bridge is selectable on a modern device — otherwise it would ship with no device coverage.

detail is structured-cloned

Building on #2000: mark/measure detail is cloned once at entry creation through the structuredClone global, so entries hold snapshots and an uncloneable detail throws the DataCloneError-named error. The builtin keeps an identity fallback so the file stays portable to a runtime shipping the Performance API before structuredClone. This is the Android side of the iOS follow-up commit 6dd55238d.

Deviations (documented in docs/performance.md)

• User-timing buffers are unbounded (per spec); clearMarks()/clearMeasures() is the release valve.
• Observer callbacks are delivered from a microtask (still asynchronous relative to mark()/measure()); callback exceptions route to reportError, so one throwing observer does not starve the others.
• No DOMException: the spec'd SyntaxError/InvalidModificationError are Error instances with name patched.
• Browser-only surface absent: no resource/navigation timing, no eventCounts.

Does your commit message include the wording below to reference a specific issue in this repo?

No — this is not tracked by an issue in this repo.

Related Pull Requests

• feat: WHATWG performance API (hr-time, user timing, performance timeline) ios#430 — the iOS PR this mirrors
• NativeScript/ios@6dd55238d — the iOS detail structured-clone follow-up this also mirrors
• feat: structuredClone global (HTML structured clone, ArrayBuffer transfer) #2000 — the base branch (feat/structured-clone), whose structuredClone global the detail clone goes through

Does your pull request have unit tests?

Yes. The cross-runtime shared suite (test-app/app/src/main/assets/app/shared/Performance, already at the pin this branch inherits) is registered from mainpage.js, contributing 56 specs — hr-time invariants, the full measure() options algebra, the timeline queries, observer semantics including buffered replay and takeRecords, detail snapshotting plus the DataCloneError case, and worker time-origin/buffer isolation. The suite gates itself on the API being present, so an unguarded Performance API canary was added to testRuntimeImplementedAPIs.js (mirroring iOS) to make a regression fail rather than silently skip. testPerformanceNow.js is removed — the shared suite supersedes it, as on iOS.

The frame-callback contract is covered by 4 new specs in testPostFrameCallback.js, run twice over — once per implementation — asserting the raw first argument stays boot-scale nanoseconds, that the second argument sits on the performance base (never ahead of a performance.now() read taken inside the callback, within a frame of it), that both advance across consecutive frames, and that the origin the two arguments imply matches the one (System.nanoTime(), performance.now()) implies. The results XML confirms the Java implementation suite ran with 2 tests / 0 skipped / 0 failures, so the API 21–23 bridge is device-tested rather than review-only.

Verified on an arm64-v8a API 35 emulator:

(+55 = 56 shared Performance specs + 1 canary − 1 self-skip gate spec − 2 superseded testPerformanceNow specs; +4 = the frame-callback specs × 2 implementations.) check_if_tests_passed.js on the pulled results XML: 749 executed, 749 passed, 0 failed. ESLint clean (npm run lint).

Summary by CodeRabbit

• New Features

  • Added a WHATWG-compatible Performance API with timing, marks, measures, entries, observers, and shared clock support.
  • Added performance.now() and timeOrigin for consistent runtime timestamps.
  • Added frame callback scheduling with native and Java Android support, including delayed callbacks.

• Documentation

  • Added comprehensive Performance API and frame callback documentation, including platform behavior and specification deviations.

• Tests

  • Expanded coverage for performance APIs, frame timestamps, clock consistency, ordering, and callback progression.