@glassly/engine 0.1.0-dev.98 → 0.2.8-dev.445

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,51 @@ 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 geometry tween (255 frames at ~30 fps); rotation uses a separate millisecond clock. */
+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
+    // Rotation has its own millisecond clock, beyond the geometry frame limit.
+    const duration = Math.min(t, el.rotation !== undefined ? 65535 : MAX_SETTLE_MS)
+    if (duration > ms) ms = duration
+  }
+  return 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
+  private settledSub: {remove: () => void} | null = null
+  private settledListeners = new Set<(seq: number) => void>()
 
   public static getInstance(): SceneRenderer {
     if (!SceneRenderer.instance) {
@@ -79,7 +115,11 @@ class SceneRenderer {
       maxImageElements: display.maxImageElements ?? 0,
       maxImagePx: display.maxImagePx,
       shapes: display.shapes ?? [],
+      animation: display.animation ?? false,
+      rotation: display.rotation ?? false,
+      depth: display.depth ?? false,
       intensityLevels: display.intensityLevels ?? 2,
+
       partialUpdate: display.partialUpdate ?? false,
     }
   }
@@ -225,12 +265,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,
+    }
   }
 
   /**
@@ -239,15 +287,90 @@ 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)
+    })
+  }
+
+  /**
+   * Fires with the host frame number once the glasses report that every
+   * animation the frame started has ended (Glassly CFW revision 27+). The
+   * device echoes the low 16 bits of the seq; the full number is recovered
+   * against the latest frame sent.
+   */
+  public onSettled(listener: (seq: number) => void): {remove: () => void} {
+    this.settledListeners.add(listener)
+    if (!this.settledSub) {
+      this.settledSub = BluetoothSdk.addListener("scene_settled", (event) => {
+        const seq = this.seqCounter - ((this.seqCounter - event.tag) & 0xffff)
+        if (seq <= 0) return
+        for (const settled of [...this.settledListeners]) settled(seq)
+      })
+    }
+    return {remove: () => this.settledListeners.delete(listener)}
+  }
+
+  /** 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)
+    }
   }
 
   /**
@@ -270,13 +393,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
+    // main frames stay committed; setOverlayOwner(null) replays them.
+    const overlayHeld = useDisplayStore.getState().overlayOwner !== null
+    if (overlayHeld !== (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.
@@ -296,13 +422,18 @@ class SceneRenderer {
         view: frame.view,
         layout: {
           layoutType: "scene",
+          appId: frame.appId,
+          view: frame.view,
+          sceneEpoch: frame.sceneEpoch,
           width: frame.canvas?.width,
           height: frame.canvas?.height,
           elements: frame.elements,
         },
       })
+      return true
     } catch (err) {
       console.error(`${LOG_TAG}: native scene send failed:`, err)
+      return false
     }
   }
 
@@ -312,6 +443,13 @@ class SceneRenderer {
 
   public _resetForTest(): void {
     this.store.clearAll()
+    this.settlePending(() => true, {presented: false, superseded: false, reason: "reset"})
+    this.presentedSub?.remove()
+    this.presentedSub = null
+    this.settledSub?.remove()
+    this.settledSub = null
+    this.settledListeners.clear()
+    this.seqCounter = 0
   }
 
   public _lastFrameForTest(appId: string, view: string): FrameElement[] {

package/src/services/StreamLifecycleController.ts

@@ -1,3 +1,5 @@
+import {BgTimer} from "../utils/timers"
+
 /**
  * Drives RTMP stream liveliness checks via a keep-alive heartbeat:
  * `setActive(true)` starts the timer; each tick sends a keep-alive with a
@@ -35,7 +37,7 @@ export interface StreamLifecycleOptions {
 
 interface PendingAckInfo {
   sentAt: number
-  timeout: ReturnType<typeof setTimeout>
+  timeout: number
 }
 
 /**
@@ -45,7 +47,7 @@ interface PendingAckInfo {
  * caller is expected to tear the stream down.
  */
 export class StreamLifecycleController {
-  private keepAliveTimer?: ReturnType<typeof setInterval>
+  private keepAliveTimer?: number
   private pendingAcks: Map<string, PendingAckInfo> = new Map()
   private missedAcks = 0
   private lastActivityMs: number
@@ -103,7 +105,7 @@ export class StreamLifecycleController {
       return
     }
 
-    clearTimeout(ackInfo.timeout)
+    BgTimer.clearTimeout(ackInfo.timeout)
     this.pendingAcks.delete(ackId)
     this.recordActivity()
 
@@ -125,7 +127,7 @@ export class StreamLifecycleController {
 
   private startTimer(): void {
     if (this.keepAliveTimer) return
-    this.keepAliveTimer = setInterval(() => {
+    this.keepAliveTimer = BgTimer.setInterval(() => {
       void this.tick()
     }, this.keepAliveIntervalMs)
     this.logger.debug({streamId: this.streamId}, "Keep-alive timer started")
@@ -133,7 +135,7 @@ export class StreamLifecycleController {
 
   private stopTimer(): void {
     if (this.keepAliveTimer) {
-      clearInterval(this.keepAliveTimer)
+      BgTimer.clearInterval(this.keepAliveTimer)
       this.keepAliveTimer = undefined
       this.logger.debug({streamId: this.streamId}, "Keep-alive timer stopped")
     }
@@ -150,7 +152,7 @@ export class StreamLifecycleController {
     const ackId = this.createAckId()
     const sentAt = this.now()
 
-    const timeout = setTimeout(() => {
+    const timeout = BgTimer.setTimeout(() => {
       this.onAckTimeout(ackId, sentAt)
     }, this.ackTimeoutMs)
 
@@ -196,7 +198,7 @@ export class StreamLifecycleController {
 
   private clearPendingAcks(): void {
     for (const {timeout} of this.pendingAcks.values()) {
-      clearTimeout(timeout)
+      BgTimer.clearTimeout(timeout)
     }
     this.pendingAcks.clear()
   }

package/src/services/TTSModelManager.ts

@@ -421,7 +421,7 @@ class TTSModelManager {
 
     const outputDir = RNFS.CachesDirectoryPath || RNFS.TemporaryDirectoryPath
     const safeId = `${Date.now()}_${Math.random().toString(36).slice(2)}`
-    const outputPath = `${outputDir}/glassly_tts_${safeId}.wav`
+    const outputPath = `${outputDir}/tts_${safeId}.wav`
     const ok = await BluetoothSdk.generateTtsAudio(
       text,
       this.getModelPath(),

package/src/services/UIRouter.ts

@@ -16,7 +16,7 @@
  *      │                                      │
  *      ▼                                      ▼
  *      ──── UIRouter.routeFromWebView   ──── UIRouter.routeFromBackground
- *           ──► Crust.jsDispatchToJs        ──► webView.injectJavaScript("window.__glassly.recv(...)")
+ *           ──► Crust.jsDispatchToJs        ──► webView.injectJavaScript("window.__host.recv(...)")
  *                {kind:"bridge", raw: JSON({
  *                  payload:{
  *                    type:"EVENT", streamType:"_ui",
@@ -71,7 +71,7 @@ export class UIRouter {
   /**
    * Called when a UI WebView mounts. `injectFn` wraps
    * `webView.injectJavaScript` — the router calls it with prebuilt
-   * `window.__glassly.recv(...)` strings to deliver background-side
+   * `window.__host.recv(...)` strings to deliver background-side
    * frames into the WebView's glassly global.
    *
    * The router also pushes a UI_OPEN envelope to the background side
@@ -194,7 +194,7 @@ export class UIRouter {
       const literal = JSON.stringify(cancel)
       const escaped = JSON.stringify(literal)
       binding.inject(
-        `if (window.__glassly && window.__glassly.recv) window.__glassly.recv(JSON.parse(${escaped})); true;`,
+        `if (window.__host && window.__host.recv) window.__host.recv(JSON.parse(${escaped})); true;`,
       )
       return
     }
@@ -208,7 +208,7 @@ export class UIRouter {
     const literal = JSON.stringify(outbound)
     const escaped = JSON.stringify(literal)
     binding.inject(
-      `if (window.__glassly && window.__glassly.recv) window.__glassly.recv(JSON.parse(${escaped})); true;`,
+      `if (window.__host && window.__host.recv) window.__host.recv(JSON.parse(${escaped})); true;`,
     )
   }
 
@@ -223,7 +223,7 @@ export class UIRouter {
     const literal = JSON.stringify(frame)
     const escaped = JSON.stringify(literal)
     binding.inject(
-      `if (window.__glassly && window.__glassly.recv) window.__glassly.recv(JSON.parse(${escaped})); true;`,
+      `if (window.__host && window.__host.recv) window.__host.recv(JSON.parse(${escaped})); true;`,
     )
   }
 

package/src/services/asg/galleryPathMigration.ts

@@ -15,7 +15,7 @@ export function toPortableGalleryPath(path: string, documentDirectoryPath: strin
 
   if (!candidate || candidate.includes("\0")) return null
   const segments = candidate.split("/")
-  if (segments[0] !== "GlasslyPhotos" || segments.some((segment) => !segment || segment === "." || segment === "..")) {
+  if (segments[0] !== "Photos" || segments.some((segment) => !segment || segment === "." || segment === "..")) {
     return null
   }
   return segments.join("/")

package/src/services/asg/gallerySyncService.ts

@@ -404,7 +404,7 @@ class GallerySyncService {
       return await Promise.race([
         CrustModule.isLocationServicesEnabled(),
         new Promise<boolean>((_, reject) =>
-          setTimeout(
+          BgTimer.setTimeout(
             () => reject(new Error("Location services check timed out")),
             TIMING.LOCATION_SERVICES_CHECK_TIMEOUT_MS,
           ),
@@ -434,7 +434,7 @@ class GallerySyncService {
         if (state !== "unknown") {
           return state === "on"
         }
-        await new Promise((resolve) => setTimeout(resolve, 50))
+        await new Promise<void>((resolve) => BgTimer.setTimeout(resolve, 50))
       }
       console.warn("[GallerySyncService] Bluetooth state still unknown after 500ms - assuming enabled")
       return true

package/src/services/asg/localStorageService.ts

@@ -51,8 +51,8 @@ export class LocalStorageService {
   private readonly CLIENT_ID_KEY = "asg_client_id"
   private readonly SYNC_QUEUE_KEY = "asg_sync_queue"
   private readonly QUARANTINED_FILES_KEY = "asg_quarantined_downloaded_files_v1"
-  private readonly ASG_PHOTOS_DIR = `${RNFS.DocumentDirectoryPath}/GlasslyPhotos`
-  private readonly ASG_THUMBNAILS_DIR = `${RNFS.DocumentDirectoryPath}/GlasslyPhotos/thumbnails`
+  private readonly ASG_PHOTOS_DIR = `${RNFS.DocumentDirectoryPath}/Photos`
+  private readonly ASG_THUMBNAILS_DIR = `${RNFS.DocumentDirectoryPath}/Photos/thumbnails`
 
   private constructor() {
     this.initializeDirectories()
@@ -248,7 +248,7 @@ export class LocalStorageService {
     let didMigrate = false
 
     // Normalize every record before saving. This fixes the old read-absolute/write-one-relative
-    // bug and migrates stale iOS container UUID paths via their Documents/GlasslyPhotos suffix.
+    // bug and migrates stale iOS container UUID paths via their Documents/Photos suffix.
     for (const [name, file] of Object.entries(files as Record<string, DownloadedFile>)) {
       const relativePath = this.toPortableRelativePath(file.filePath)
       const relativeThumbnailPath = file.thumbnailPath

package/src/services/debug/DashboardOpenTrace.ts

@@ -0,0 +1,153 @@
+/**
+ * Dashboard open timing (Debug Settings): stamps a dashboard open from the
+ * gesture reaching the phone to the glasses presenting the first overlay
+ * frame, logs it, and hands it to the host, which posts it as a phone
+ * notification. Only a gesture with the setting on starts a trace; every
+ * other entry is a no-op while none runs.
+ */
+import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
+
+import {useDisplayStore} from "../../stores/display"
+import {useGlassesStore} from "../../stores/glasses"
+import {SETTINGS, useSettingsStore} from "../../stores/settings"
+import {BgTimer} from "../../utils/timers"
+import {isGlassesConnected} from "../GlassesReadiness"
+import {onOverlayAppsChange, overlayApps} from "../pages/overlayApps"
+import {
+  DashboardOpenTimeline,
+  formatDashboardOpenTrace,
+  type DashboardOpenTrace,
+  type DashboardOpenTrigger,
+} from "./dashboardOpenTimeline"
+
+const LOG_TAG = "DashboardOpenTrace"
+
+export interface DashboardOpenReport {
+  title: string
+  body: string
+  trace: DashboardOpenTrace
+}
+
+class DashboardOpenTracer {
+  private readonly timeline = new DashboardOpenTimeline({
+    now: () => Date.now(),
+    setTimeout: (callback, ms) => BgTimer.setTimeout(callback, ms),
+    clearTimeout: (handle) => BgTimer.clearTimeout(handle),
+    onFinished: (trace) => this.report(trace),
+  })
+  private listeners = new Set<(report: DashboardOpenReport) => void>()
+  private lastOpenAt: number | null = null
+  private overlayConnectedAt = new Map<string, number>()
+  private glassesConnectedAt: number | null = null
+  private frameSubs: Array<{remove: () => void}> = []
+  private unsubs: Array<() => void> = []
+
+  /** Track the context an open is judged against. Idempotent; returns the stop. */
+  start(): () => void {
+    if (this.unsubs.length === 0) {
+      this.syncOverlayApps()
+      this.syncGlasses(isGlassesConnected(useGlassesStore.getState().connection))
+      this.unsubs.push(
+        onOverlayAppsChange(() => this.syncOverlayApps()),
+        useGlassesStore.subscribe(
+          (state) => isGlassesConnected(state.connection),
+          (connected) => this.syncGlasses(connected),
+        ),
+      )
+    }
+    return () => this.stop()
+  }
+
+  stop(): void {
+    for (const unsub of this.unsubs) unsub()
+    this.unsubs = []
+    this.timeline.cancel()
+    this.unwatchFrames()
+  }
+
+  onReport(listener: (report: DashboardOpenReport) => void): () => void {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  /** An opening gesture reached the phone; `nativeAt` is native's receipt time when the event has one. */
+  trigger(trigger: DashboardOpenTrigger, nativeAt?: number): void {
+    if (useSettingsStore.getState().getSetting(SETTINGS.debug_dashboard_open_timing.key) !== true) return
+    // With a page up the gesture moves within the dashboard or closes it.
+    if (useDisplayStore.getState().overlayOwner !== null) return
+    const now = Date.now()
+    this.timeline.trigger(
+      trigger,
+      {
+        sinceLastOpenMs: this.lastOpenAt === null ? null : now - this.lastOpenAt,
+        glassesUpMs: this.glassesConnectedAt === null ? null : now - this.glassesConnectedAt,
+      },
+      nativeAt,
+    )
+  }
+
+  showViewRequested(packageName: string): void {
+    this.timeline.showViewRequested(this.overlayConnectedAt.get(packageName) ?? null)
+  }
+
+  slotGranted(): void {
+    this.lastOpenAt = Date.now()
+    this.timeline.slotGranted()
+  }
+
+  frameSent(seq: number): void {
+    if (!this.timeline.tracing || this.timeline.frameSeq !== null) return
+    this.timeline.frameSent(seq)
+    if (this.timeline.frameSeq !== null) this.watchFrames()
+  }
+
+  // Raw device events rather than SceneRenderer.whenPresented: that keeps one
+  // waiter per seq, and the display manager's awaited render already holds it.
+  private watchFrames(): void {
+    if (this.frameSubs.length > 0) return
+    this.frameSubs.push(
+      BluetoothSdk.addListener("scene_frame_presented", (event) => {
+        this.timeline.framePresented(event.seq, event.presented, event.reason)
+      }),
+      BluetoothSdk.addListener("scene_settled", (event) => {
+        const frameSeq = this.timeline.frameSeq
+        if (frameSeq === null) return
+        // The device echoes the low 16 bits of the frame number.
+        const ahead = (event.tag - frameSeq) & 0xffff
+        if (ahead < 0x8000) this.timeline.frameSettled(frameSeq + ahead)
+      }),
+    )
+  }
+
+  private unwatchFrames(): void {
+    for (const sub of this.frameSubs) sub.remove()
+    this.frameSubs = []
+  }
+
+  private report(trace: DashboardOpenTrace): void {
+    this.unwatchFrames()
+    const {title, body} = formatDashboardOpenTrace(trace)
+    console.log(`${LOG_TAG}: ${title} | ${body.split("\n").join(" | ")}`)
+    for (const listener of Array.from(this.listeners)) listener({title, body, trace})
+  }
+
+  private syncOverlayApps(): void {
+    const running = new Set(overlayApps())
+    for (const packageName of this.overlayConnectedAt.keys()) {
+      if (!running.has(packageName)) this.overlayConnectedAt.delete(packageName)
+    }
+    for (const packageName of running) {
+      if (!this.overlayConnectedAt.has(packageName)) this.overlayConnectedAt.set(packageName, Date.now())
+    }
+  }
+
+  private syncGlasses(connected: boolean): void {
+    if (!connected) this.glassesConnectedAt = null
+    else if (this.glassesConnectedAt === null) this.glassesConnectedAt = Date.now()
+  }
+}
+
+const dashboardOpenTrace = new DashboardOpenTracer()
+export default dashboardOpenTrace