@glassly/engine 0.1.0-dev.118 → 0.1.0-dev.120

package/src/services/SceneRenderer.ts

@@ -18,6 +18,7 @@ import {SETTINGS, useSettingsStore} from "../stores/settings"
 import {useGlassesStore} from "../stores/glasses"
 import {DeviceTypes} from "../types"
 import {getEffectiveCapabilities} from "./effectiveCapabilities"
+import {BgTimer} from "../utils/timers"
 import {
   degradeScene,
   diffScene,
@@ -37,16 +38,47 @@ const LOG_TAG = "SCENE_RENDERER"
 export type LegacyLayout = {layoutType: string; [key: string]: unknown}
 
 export type SceneEmitResult =
-  /** A SceneFrame went to native. */
-  | {kind: "scene"; degraded: boolean; dropped: string[]}
+  /**
+   * A SceneFrame was committed. `sent` is false when the frame stayed
+   * phone-side (dashboard covering main). `settleMs` is how long the device
+   * keeps animating after it has the frame: the longest transition among the
+   * elements this frame changed, 0 on devices that jump.
+   */
+  | {kind: "scene"; degraded: boolean; dropped: string[]; seq: number; sent: boolean; settleMs: number}
   /** Degrade path: caller routes this legacy layout through the existing pipeline (null layout ⇒ clear). */
   | {kind: "legacy"; layout: LegacyLayout | null; degraded: boolean; dropped: string[]}
   /** No display capabilities on the connected device. */
   | {kind: "no-display"}
 
+/** How a frame ended up, as reported by native (or inferred from a later frame's report). */
+export interface ScenePresentation {
+  /** The device had the frame's content (this frame or a later one that folded it in). */
+  presented: boolean
+  /** A later frame's report settled this one. */
+  superseded: boolean
+  reason?: string
+}
+
+/** Longest tween the G2 CFW encodes (255 frames at ~30 fps); nothing waits past it. */
+const MAX_SETTLE_MS = 255 * 33
+
+/** Longest transition among the elements that actually change on the device this frame. */
+function settleTimeOf(elements: FrameElement[]): number {
+  let ms = 0
+  for (const el of elements) {
+    if (el.change !== "updated" && el.change !== "moved") continue
+    const t = el.transition?.durationMs ?? 0
+    if (t > ms) ms = t
+  }
+  return Math.min(ms, MAX_SETTLE_MS)
+}
+
 class SceneRenderer {
   private static instance: SceneRenderer | null = null
   private store = new SceneStore()
+  private seqCounter = 0
+  private pending = new Map<number, {appId: string; resolve: (p: ScenePresentation) => void}>()
+  private presentedSub: {remove: () => void} | null = null
 
   public static getInstance(): SceneRenderer {
     if (!SceneRenderer.instance) {
@@ -226,12 +258,20 @@ class SceneRenderer {
       appId,
       view,
       sceneEpoch: this.store.currentEpoch(appId, view),
+      seq: ++this.seqCounter,
       elements: diffed,
       removed,
       canvas,
     }
-    this.sendFrame(frame)
-    return {kind: "scene", degraded: processed.degraded, dropped: processed.dropped}
+    const sent = this.sendFrame(frame)
+    return {
+      kind: "scene",
+      degraded: processed.degraded,
+      dropped: processed.dropped,
+      seq: frame.seq,
+      sent,
+      settleMs: caps.animation ? settleTimeOf(diffed) : 0,
+    }
   }
 
   /**
@@ -240,15 +280,72 @@ class SceneRenderer {
    * Returns false when nothing is retained.
    */
   public replayApp(appId: string, view: "main" | "dashboard"): boolean {
-    const frame = this.store.buildReplayFrame(appId, view)
+    const frame = this.store.buildReplayFrame(appId, view, ++this.seqCounter)
     if (!frame) return false
     this.sendFrame(frame)
     return true
   }
 
-  /** Forget an app's retained scenes (app stop). */
+  /** Forget an app's retained scenes (app stop). Frames still in flight will never show. */
   public clearApp(appId: string): void {
     this.store.clear(appId)
+    this.settlePending((p) => p.appId === appId, {presented: false, superseded: true, reason: "cleared"})
+  }
+
+  // ===========================================================================
+  // Presentation — native reports when the device has a frame
+  // ===========================================================================
+
+  /**
+   * Resolves once native reports frame `seq` on the device, or a later frame
+   * that folded it in. Never rejects; `timeoutMs` bounds a frame the device
+   * never acknowledges (link stalls, page rebuilding).
+   */
+  public whenPresented(seq: number, timeoutMs: number, appId: string): Promise<ScenePresentation> {
+    this.ensurePresentedListener()
+    return new Promise((resolve) => {
+      const timer = BgTimer.setTimeout(() => {
+        if (this.pending.delete(seq)) resolve({presented: false, superseded: false, reason: "no presentation report"})
+      }, timeoutMs)
+      this.pending.set(seq, {
+        appId,
+        resolve: (p) => {
+          BgTimer.clearTimeout(timer)
+          resolve(p)
+        },
+      })
+    })
+  }
+
+  private ensurePresentedListener(): void {
+    if (this.presentedSub) return
+    this.presentedSub = BluetoothSdk.addListener("scene_frame_presented", (event) => {
+      this.onFramePresented(event.seq, event.appId, event.presented, event.reason)
+    })
+  }
+
+  /** A report for `seq` settles it and every earlier frame (folded in by the native pacer). */
+  private onFramePresented(seq: number, appId: string, presented: boolean, reason?: string): void {
+    this.settlePending(
+      (p, s) => s <= seq,
+      (p, s) =>
+        s === seq
+          ? {presented, superseded: false, reason}
+          : p.appId === appId
+            ? {presented, superseded: true, reason}
+            : {presented: false, superseded: true, reason: `superseded by ${appId}`},
+    )
+  }
+
+  private settlePending(
+    match: (p: {appId: string}, seq: number) => boolean,
+    outcome: ScenePresentation | ((p: {appId: string}, seq: number) => ScenePresentation),
+  ): void {
+    for (const [seq, p] of [...this.pending]) {
+      if (!match(p, seq)) continue
+      this.pending.delete(seq)
+      p.resolve(typeof outcome === "function" ? outcome(p, seq) : outcome)
+    }
   }
 
   /**
@@ -271,13 +368,16 @@ class SceneRenderer {
    */
   public markViewStale(view: "main" | "dashboard"): void {
     this.store.markViewStale(view)
+    // Whatever was in flight for the view got wiped with it.
+    this.settlePending(() => true, {presented: false, superseded: true, reason: "cleared"})
   }
 
-  private sendFrame(frame: SceneFrame): void {
+  /** Returns false when the frame stayed phone-side (no presentation report will follow). */
+  private sendFrame(frame: SceneFrame): boolean {
     // Single native view: only the visible surface's frames go out. Suppressed
     // main frames stay committed; setDashboardActive(false) replays them.
     const dashboardActive = useDisplayStore.getState().dashboardActive
-    if (dashboardActive !== (frame.view === "dashboard")) return
+    if (dashboardActive !== (frame.view === "dashboard")) return false
     try {
       // Frames carry the canvas they were laid out against; only a frame from
       // a path that predates the tag falls back to the current capabilities.
@@ -302,8 +402,10 @@ class SceneRenderer {
           elements: frame.elements,
         },
       })
+      return true
     } catch (err) {
       console.error(`${LOG_TAG}: native scene send failed:`, err)
+      return false
     }
   }
 
@@ -313,6 +415,10 @@ class SceneRenderer {
 
   public _resetForTest(): void {
     this.store.clearAll()
+    this.settlePending(() => true, {presented: false, superseded: false, reason: "reset"})
+    this.presentedSub?.remove()
+    this.presentedSub = null
+    this.seqCounter = 0
   }
 
   public _lastFrameForTest(appId: string, view: string): FrameElement[] {