@glassly/engine 0.1.0-dev.99 → 0.2.9-beta.448

package/src/services/NativeNavigationService.ts

@@ -3,16 +3,18 @@
  * firmware-rendered nav UI (`hasNativeNavigation`; G2 service 0x08 today).
  * NavigationHandlers drives enter/exit at trip boundaries; miniapp NATIVE_NAV
  * payloads (card fields, map bitmaps) are forwarded to the bluetooth-sdk.
- * While active, the glasses magnetometer feeds HeadingService so
- * session.heading serves the glasses compass instead of the phone's.
+ * While active, stock firmware streams its magnetometer heading; the device
+ * event router forwards it to session.compass like any glasses compass sample.
  */
 
+import {useDisplayStore} from "../stores/display"
 import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
 
 import {ISLAND_SETTINGS_KEYS} from "../runtime/config"
 import {useSettingsStore} from "../stores/settings"
-import {DeviceTypes, getModelCapabilities} from "../types"
-import headingService from "./HeadingService"
+import {DeviceTypes} from "../types"
+import {getEffectiveCapabilities} from "./effectiveCapabilities"
+import glassesSensorService from "./GlassesSensorService"
 
 const LOG_TAG = "NATIVE_NAV_SERVICE"
 
@@ -30,7 +32,6 @@ class NativeNavigationService {
   private static instance: NativeNavigationService | null = null
 
   private active = false
-  private compassSub: {remove: () => void} | null = null
   private modeSub: {remove: () => void} | null = null
   /** Registered by NavigationHandlers; fires when the WEARER exits nav mode on the glasses. */
   private onGlassesExitCb: (() => void) | null = null
@@ -62,7 +63,9 @@ class NativeNavigationService {
     const defaultWearable = useSettingsStore.getState().getSetting(ISLAND_SETTINGS_KEYS.defaultWearable) as
       | DeviceTypes
       | undefined
-    const capabilities = getModelCapabilities(defaultWearable || DeviceTypes.NONE)
+    // Effective, not model: custom firmware drops hasNativeNavigation so the
+    // miniapp's scene HUD owns the display (see effectiveCapabilities).
+    const capabilities = getEffectiveCapabilities(defaultWearable || DeviceTypes.NONE)
     return (
       capabilities.hasNativeNavigation === true &&
       typeof (BluetoothSdk as {navigationModeStart?: unknown}).navigationModeStart === "function"
@@ -74,10 +77,16 @@ class NativeNavigationService {
     if (!this.isSupported() || this.active) return
     console.log(`${LOG_TAG}: entering native nav mode for ${packageName}`)
     this.active = true
+    useDisplayStore.getState().setDisplayEvent({layout: {layoutType: "unavailable", reason: "firmware-navigation"}})
     this.attachListeners()
-    void Promise.resolve(BluetoothSdk.navigationModeStart()).catch((err) => {
-      console.error(`${LOG_TAG}: navigationModeStart failed:`, err)
-    })
+    void glassesSensorService
+      .setNavigationActive(true)
+      .then(() => {
+        return this.active ? BluetoothSdk.navigationModeStart() : undefined
+      })
+      .catch((err) => {
+        console.error(`${LOG_TAG}: navigationModeStart failed:`, err)
+      })
   }
 
   /** The trip ended (arrived / stopped / errored). Safe to call when inactive. */
@@ -85,9 +94,13 @@ class NativeNavigationService {
     if (!this.active) return
     console.log(`${LOG_TAG}: exiting native nav mode (arrived=${arrived})`)
     this.teardown()
-    void Promise.resolve(BluetoothSdk.navigationModeStop(arrived)).catch((err) => {
-      console.error(`${LOG_TAG}: navigationModeStop failed:`, err)
-    })
+    void Promise.resolve(BluetoothSdk.navigationModeStop(arrived))
+      .then(() => {
+        return glassesSensorService.setNavigationActive(false)
+      })
+      .catch((err) => {
+        console.error(`${LOG_TAG}: navigationModeStop failed:`, err)
+      })
   }
 
   /**
@@ -140,15 +153,6 @@ class NativeNavigationService {
   }
 
   private attachListeners(): void {
-    // Glasses magnetometer → session.heading for the duration of the trip.
-    headingService.setExternalSourceActive(true)
-    this.compassSub?.remove()
-    this.compassSub = BluetoothSdk.addListener("compass_heading", (event) => {
-      const deg = Number(event.heading)
-      if (!Number.isFinite(deg)) return
-      headingService.pushExternalHeading(((deg % 360) + 360) % 360)
-    })
-
     // Glasses-side exit ends the whole trip: release the compass override and
     // let NavigationHandlers stop navigation + notify the miniapp ("cancelled").
     // Phone-initiated exits (trip already ending) just tear down.
@@ -157,18 +161,18 @@ class NativeNavigationService {
       if (event.status === "exited" && this.active) {
         console.log(`${LOG_TAG}: nav mode exited natively (source=${event.source ?? "phone"})`)
         this.teardown()
-        if (event.source === "glasses") this.onGlassesExitCb?.()
+        if (event.source === "glasses") {
+          this.onGlassesExitCb?.()
+          void glassesSensorService.setNavigationActive(false)
+        }
       }
     })
   }
 
   private teardown(): void {
     this.active = false
-    this.compassSub?.remove()
-    this.compassSub = null
     this.modeSub?.remove()
     this.modeSub = null
-    headingService.setExternalSourceActive(false)
   }
 }
 

package/src/services/NavigationHandlers.ts

@@ -240,7 +240,12 @@ export class NavigationHandlers {
         // navigation mode for the duration of the trip.
         nativeNavigationService.onTripStart(packageName)
       }
-      this.sendResult(packageName, requestId, result.ok, result, undefined)
+      // A refused start (`{ok: false, error}` from the token gate or the
+      // native navigator) is request DATA, not a wire failure: the SDK's
+      // navigation.start() contract is "resolves {ok, error?}, never throws".
+      // Sending it as ok:false on the wire made the SDK reject with its
+      // generic "Unknown error" and drop the real message.
+      this.sendResult(packageName, requestId, true, result)
     } catch (err) {
       console.error(`${LOG_TAG}: navigation start error:`, err)
       this.sendResult(packageName, requestId, false, undefined, {
@@ -263,7 +268,7 @@ export class NavigationHandlers {
         nativeNavigationService.onTripEnd(false)
         const navigation = navigationService
         const result = navigation ? await navigation.stop() : {ok: true}
-        this.sendResult(packageName, requestId, result.ok, result, undefined)
+        this.sendResult(packageName, requestId, true, result)
       } else {
         this.sendResult(packageName, requestId, true, {ok: true}, undefined)
       }
@@ -284,7 +289,7 @@ export class NavigationHandlers {
       const result = navigation
         ? await navigation.simulateDeviation(offsetMeters)
         : {ok: false, error: "navigation adapter not configured"}
-      this.sendResult(packageName, requestId, result.ok, result, undefined)
+      this.sendResult(packageName, requestId, true, result)
     } catch (err) {
       console.error(`${LOG_TAG}: navigation deviate error:`, err)
       this.sendResult(packageName, requestId, false, undefined, {
@@ -305,7 +310,7 @@ export class NavigationHandlers {
       const result = navigation
         ? await navigation.setWrongSidewalkOffset(enabled)
         : {ok: false, error: "navigation adapter not configured"}
-      this.sendResult(packageName, requestId, result.ok, result, undefined)
+      this.sendResult(packageName, requestId, true, result)
     } catch (err) {
       console.error(`${LOG_TAG}: navigation setWrongSidewalkOffset error:`, err)
       this.sendResult(packageName, requestId, false, undefined, {
@@ -326,7 +331,7 @@ export class NavigationHandlers {
       const result = navigation
         ? await navigation.setSkipCrossings(enabled)
         : {ok: false, error: "navigation adapter not configured"}
-      this.sendResult(packageName, requestId, result.ok, result, undefined)
+      this.sendResult(packageName, requestId, true, result)
     } catch (err) {
       console.error(`${LOG_TAG}: navigation setSkipCrossings error:`, err)
       this.sendResult(packageName, requestId, false, undefined, {

package/src/services/OtaInstallCoordinator.ts

@@ -57,6 +57,8 @@ import {
   type OtaProtocolProfile,
 } from "./otaInstallPolicy"
 
+import {BgTimer} from "../utils/timers"
+
 function isTerminalForWatchdog(d: DisplayState): boolean {
   return d === "complete" || d === "failed" || d === "restarting"
 }
@@ -239,18 +241,18 @@ class OtaInstallCoordinator {
   private lastRealMtkProgress = 0
 
   // Timer handles
-  private globalTimeout: ReturnType<typeof setTimeout> | null = null
+  private globalTimeout: number | null = null
   private globalTimeoutStarted = false
-  private retryTimeout: ReturnType<typeof setTimeout> | null = null
-  private stuckTimeout: ReturnType<typeof setTimeout> | null = null
-  private progressTimeout: ReturnType<typeof setTimeout> | null = null
-  private pingInterval: ReturnType<typeof setInterval> | null = null
-  private queryReplyTimeout: ReturnType<typeof setTimeout> | null = null
-  private continueLockoutTimer: ReturnType<typeof setTimeout> | null = null
-  private restartRecoveryTimeout: ReturnType<typeof setTimeout> | null = null
-  private legacyApkSettleTimer: ReturnType<typeof setTimeout> | null = null
-  private mtkStallDetectTimer: ReturnType<typeof setTimeout> | null = null
-  private mtkSimTickTimer: ReturnType<typeof setInterval> | null = null
+  private retryTimeout: number | null = null
+  private stuckTimeout: number | null = null
+  private progressTimeout: number | null = null
+  private pingInterval: number | null = null
+  private queryReplyTimeout: number | null = null
+  private continueLockoutTimer: number | null = null
+  private restartRecoveryTimeout: number | null = null
+  private legacyApkSettleTimer: number | null = null
+  private mtkStallDetectTimer: number | null = null
+  private mtkSimTickTimer: number | null = null
 
   // Request / retry bookkeeping (no glasses source)
   // At most one apk-install status poll in flight (native rejects concurrent queries).
@@ -950,7 +952,7 @@ class OtaInstallCoordinator {
       if (active) {
         void BluetoothSdk.ping().catch(() => {})
         const pingIntervalMs = legacySession ? LEGACY_PING_INTERVAL_MS : PING_INTERVAL_MS
-        this.pingInterval = setInterval(() => {
+        this.pingInterval = BgTimer.setInterval(() => {
           void BluetoothSdk.ping().catch(() => {})
           this.maybePollApkInstallStatus()
         }, pingIntervalMs)
@@ -990,7 +992,7 @@ class OtaInstallCoordinator {
       } else {
         const duration = stallDuration
         this.clearProgressTimeout()
-        this.progressTimeout = setTimeout(() => {
+        this.progressTimeout = BgTimer.setTimeout(() => {
           this.progressTimeout = null
           if (isTerminalForWatchdog(this.computeDisplayStateNow())) return
           console.log(`[OTA_PROGRESS] watchdog: progress stalled for ${duration}ms, failing`)
@@ -1007,11 +1009,11 @@ class OtaInstallCoordinator {
       const lockoutMs = legacySession ? LEGACY_BES_CONTINUE_LOCKOUT_MS : BES_CONTINUE_LOCKOUT_MS
       const restartTimeoutMs = legacySession ? LEGACY_BES_RESTART_TIMEOUT_MS : BES_RESTART_TIMEOUT_MS
       this.setContinueButtonDisabled(true)
-      this.continueLockoutTimer = setTimeout(() => {
+      this.continueLockoutTimer = BgTimer.setTimeout(() => {
         this.continueLockoutTimer = null
         this.setContinueButtonDisabled(false)
       }, lockoutMs)
-      this.restartRecoveryTimeout = setTimeout(() => {
+      this.restartRecoveryTimeout = BgTimer.setTimeout(() => {
         this.restartRecoveryTimeout = null
         if (this.computeDisplayStateNow() !== "restarting") return
         console.log(`[OTA_PROGRESS] watchdog: glasses did not finish restarting in ${restartTimeoutMs}ms`)
@@ -1212,7 +1214,7 @@ class OtaInstallCoordinator {
         `[OTA_PROGRESS] legacy apk install complete — holding complete for ${LEGACY_APK_COMPLETION_SETTLE_MS}ms settle window`,
       )
       this.setLegacyApkSettleHold(true)
-      this.legacyApkSettleTimer = setTimeout(() => {
+      this.legacyApkSettleTimer = BgTimer.setTimeout(() => {
         this.legacyApkSettleTimer = null
         console.log("[OTA_PROGRESS] legacy apk settle window elapsed — releasing complete")
         this.setLegacyApkSettleHold(false)
@@ -1292,7 +1294,7 @@ class OtaInstallCoordinator {
       realProgress >= LEGACY_MTK_STALL_ZONE_MIN_PERCENT && realProgress < LEGACY_MTK_STALL_ZONE_MAX_PERCENT
     if (!inStallZone) return
 
-    this.mtkStallDetectTimer = setTimeout(() => {
+    this.mtkStallDetectTimer = BgTimer.setTimeout(() => {
       this.mtkStallDetectTimer = null
       const stalledAt = this.lastRealMtkProgress
       const prev = this.mtkSimulatedPercent
@@ -1304,12 +1306,12 @@ class OtaInstallCoordinator {
         `[OTA_PROGRESS] legacy mtk install stalled at ${stalledAt}%, simulating display progress from ${target}%`,
       )
       this.setMtkSimulatedPercent(target)
-      this.mtkSimTickTimer = setInterval(() => {
+      this.mtkSimTickTimer = BgTimer.setInterval(() => {
         const current = this.mtkSimulatedPercent ?? stalledAt + 1
         const capped = Math.min(current + 1, LEGACY_MTK_SIM_CAP_PERCENT)
         this.setMtkSimulatedPercent(capped)
         if (capped >= LEGACY_MTK_SIM_CAP_PERCENT && this.mtkSimTickTimer) {
-          clearInterval(this.mtkSimTickTimer)
+          BgTimer.clearInterval(this.mtkSimTickTimer)
           this.mtkSimTickTimer = null
         }
       }, LEGACY_MTK_SIM_TICK_MS)
@@ -1404,7 +1406,7 @@ class OtaInstallCoordinator {
     // session; a session that starts unified keeps the unified cap.
     const globalTimeoutMs =
       this.versionChangeSession || this.isLegacySessionShapeNow() ? LEGACY_GLOBAL_OTA_TIMEOUT_MS : GLOBAL_OTA_TIMEOUT_MS
-    this.globalTimeout = setTimeout(() => {
+    this.globalTimeout = BgTimer.setTimeout(() => {
       this.globalTimeout = null
       this.globalTimeoutStarted = false
       if (isTerminalForWatchdog(this.computeDisplayStateNow())) return
@@ -1427,7 +1429,7 @@ class OtaInstallCoordinator {
     const legacySession = this.isLegacySessionShapeNow()
     const stuckTimeoutMs = legacySession ? LEGACY_DOWNLOAD_STUCK_TIMEOUT_MS : DOWNLOAD_STUCK_TIMEOUT_MS
 
-    this.stuckTimeout = setTimeout(() => {
+    this.stuckTimeout = BgTimer.setTimeout(() => {
       this.stuckTimeout = null
       const d = this.computeDisplayStateNow()
       const state = useGlassesStore.getState()
@@ -1560,7 +1562,7 @@ class OtaInstallCoordinator {
             this.retryCount + 1
           }/${MAX_RETRIES})`,
         )
-        this.retryTimeout = setTimeout(() => {
+        this.retryTimeout = BgTimer.setTimeout(() => {
           this.retryTimeout = null
           if (!isGlassesConnected(useGlassesStore.getState().connection)) {
             console.log("[OTA_PROGRESS] ota_start retry paused while disconnected; reconnect arbitration will resume")
@@ -1598,7 +1600,7 @@ class OtaInstallCoordinator {
    */
   private armQueryReplyFallback(reason: "reconnect" | "initial-mount" | "retry"): void {
     this.clearQueryReplyTimeout()
-    this.queryReplyTimeout = setTimeout(() => {
+    this.queryReplyTimeout = BgTimer.setTimeout(() => {
       this.queryReplyTimeout = null
       const state = useGlassesStore.getState()
       // If we already got a useful reply, we'd have been cleared. Defensive
@@ -1633,28 +1635,28 @@ class OtaInstallCoordinator {
 
   private clearProgressTimeout(): void {
     if (this.progressTimeout) {
-      clearTimeout(this.progressTimeout)
+      BgTimer.clearTimeout(this.progressTimeout)
       this.progressTimeout = null
     }
   }
 
   private clearRetryTimeout(): void {
     if (this.retryTimeout) {
-      clearTimeout(this.retryTimeout)
+      BgTimer.clearTimeout(this.retryTimeout)
       this.retryTimeout = null
     }
   }
 
   private clearStuckTimeout(): void {
     if (this.stuckTimeout) {
-      clearTimeout(this.stuckTimeout)
+      BgTimer.clearTimeout(this.stuckTimeout)
       this.stuckTimeout = null
     }
   }
 
   private clearGlobalTimeout(): void {
     if (this.globalTimeout) {
-      clearTimeout(this.globalTimeout)
+      BgTimer.clearTimeout(this.globalTimeout)
       this.globalTimeout = null
     }
     this.globalTimeoutStarted = false
@@ -1662,46 +1664,46 @@ class OtaInstallCoordinator {
 
   private clearPingInterval(): void {
     if (this.pingInterval) {
-      clearInterval(this.pingInterval)
+      BgTimer.clearInterval(this.pingInterval)
       this.pingInterval = null
     }
   }
 
   private clearQueryReplyTimeout(): void {
     if (this.queryReplyTimeout) {
-      clearTimeout(this.queryReplyTimeout)
+      BgTimer.clearTimeout(this.queryReplyTimeout)
       this.queryReplyTimeout = null
     }
   }
 
   private clearContinueLockoutTimer(): void {
     if (this.continueLockoutTimer) {
-      clearTimeout(this.continueLockoutTimer)
+      BgTimer.clearTimeout(this.continueLockoutTimer)
       this.continueLockoutTimer = null
     }
   }
 
   private clearRestartRecoveryTimeout(): void {
     if (this.restartRecoveryTimeout) {
-      clearTimeout(this.restartRecoveryTimeout)
+      BgTimer.clearTimeout(this.restartRecoveryTimeout)
       this.restartRecoveryTimeout = null
     }
   }
 
   private clearLegacyApkSettleTimer(): void {
     if (this.legacyApkSettleTimer) {
-      clearTimeout(this.legacyApkSettleTimer)
+      BgTimer.clearTimeout(this.legacyApkSettleTimer)
       this.legacyApkSettleTimer = null
     }
   }
 
   private clearMtkSimulationTimers(): void {
     if (this.mtkStallDetectTimer) {
-      clearTimeout(this.mtkStallDetectTimer)
+      BgTimer.clearTimeout(this.mtkStallDetectTimer)
       this.mtkStallDetectTimer = null
     }
     if (this.mtkSimTickTimer) {
-      clearInterval(this.mtkSimTickTimer)
+      BgTimer.clearInterval(this.mtkSimTickTimer)
       this.mtkSimTickTimer = null
     }
   }

package/src/services/PairedGlassesLatch.ts

@@ -0,0 +1,39 @@
+/**
+ * PairedGlassesLatch — records that this phone has, at some point, paired
+ * real glasses. Projects the pairing identity (see PairingIdentity) into the
+ * one-way `has_paired_glasses` setting: set the first time the identity reads
+ * `paired` to a non-simulated model, never cleared. Forgetting the glasses or
+ * switching models leaves it on, so what it unlocks (the Store, see
+ * stores/appVisibility PAIRED_GLASSES_PACKAGES) stays unlocked.
+ */
+import {useSettingsStore, SETTINGS} from "../stores/settings"
+import {DeviceTypes} from "../types"
+import {projectPairingIdentity, subscribePairingIdentity, type IdentitySnapshot} from "./PairingIdentity"
+
+/** Paired to real glasses: the simulated device is its own identity and does not count. */
+export const isPairedToRealGlasses = (identity: IdentitySnapshot): boolean =>
+  identity.kind === "paired" && !identity.model.includes(DeviceTypes.SIMULATED)
+
+let unsubscribe: (() => void) | null = null
+
+function latch(identity: IdentitySnapshot): void {
+  if (identity.kind !== "paired" || !isPairedToRealGlasses(identity)) return
+  const store = useSettingsStore.getState()
+  if (store.getSetting(SETTINGS.has_paired_glasses.key) === true) return
+  console.log(`PairedGlassesLatch: first real pairing ("${identity.model}") -> has_paired_glasses`)
+  void Promise.resolve(store.setSetting(SETTINGS.has_paired_glasses.key, true, false)).then((r) => {
+    if (r.is_error()) console.warn("PairedGlassesLatch: failed to persist has_paired_glasses:", r.error)
+  })
+}
+
+/** Start after the persisted settings are loaded so an already-paired phone latches immediately. */
+export function startPairedGlassesLatch(): void {
+  if (unsubscribe) return
+  latch(projectPairingIdentity())
+  unsubscribe = subscribePairingIdentity(latch)
+}
+
+export function stopPairedGlassesLatch(): void {
+  unsubscribe?.()
+  unsubscribe = null
+}

package/src/services/PhoneActivity.ts

@@ -0,0 +1,116 @@
+/**
+ * Phone activity — engine-owned, both platforms. Started by `engine.start()`.
+ *
+ * "Active" means the wearer can see the phone: the Glassly App is in the
+ * foreground, or the phone is unlocked. Crust reports lock state as
+ * `phone_lock_state` (iOS: protected-data availability; Android: screen on and
+ * keyguard hidden); React Native reports foregrounding. Consumers read
+ * `isPhoneActive()` at decision time — the dashboard reducer when a
+ * notification posts — and `onPhoneActivityChange` serves those that have to
+ * push the state somewhere, like the stock G2 firmware's notification ctrl.
+ */
+import {AppState} from "react-native"
+import type {AppStateStatus} from "react-native"
+import CrustModule from "@glassly/crust"
+import type {PhoneLockState} from "@glassly/crust"
+
+type Listener = (active: boolean) => void
+
+let started = false
+let lockStateSubscription: {remove(): void} | null = null
+let appStateSubscription: {remove(): void} | null = null
+const listeners = new Set<Listener>()
+const foregroundListeners = new Set<Listener>()
+
+// Until native answers, assume locked so a failed query never reads as active.
+const ASSUMED_LOCKED: PhoneLockState = {unlocked: false, passcodeSet: true}
+let phoneLock: PhoneLockState = ASSUMED_LOCKED
+let appForegrounded = false
+
+/**
+ * A foregrounded app is proof on its own. Without a passcode the platform lock
+ * signal is meaningless (iOS reports protected data as always available), so
+ * only the foreground gate applies there.
+ */
+export function computePhoneActive(lock: PhoneLockState, foregrounded: boolean): boolean {
+  if (foregrounded) return true
+  if (!lock.passcodeSet) return false
+  return lock.unlocked
+}
+
+export function isPhoneActive(): boolean {
+  return computePhoneActive(phoneLock, appForegrounded)
+}
+
+/**
+ * Whether the Glassly App itself is foregrounded, independent of the lock
+ * state that `isPhoneActive()` folds in. Background execution limits (timer
+ * coalescing, BLE pacing) follow this bit alone: a backgrounded app on an
+ * unlocked phone is still a backgrounded app.
+ */
+export function isAppForegrounded(): boolean {
+  return appForegrounded
+}
+
+/** Fires on app foreground/background transitions only. See `isAppForegrounded`. */
+export function onAppForegroundChange(listener: Listener): () => void {
+  foregroundListeners.add(listener)
+  return () => {
+    foregroundListeners.delete(listener)
+  }
+}
+
+export function onPhoneActivityChange(listener: Listener): () => void {
+  listeners.add(listener)
+  return () => {
+    listeners.delete(listener)
+  }
+}
+
+function update(next: {lock?: PhoneLockState; foregrounded?: boolean}): void {
+  const before = isPhoneActive()
+  const foregroundBefore = appForegrounded
+  if (next.lock) phoneLock = next.lock
+  if (next.foregrounded !== undefined) appForegrounded = next.foregrounded
+  if (appForegrounded !== foregroundBefore) {
+    for (const listener of Array.from(foregroundListeners)) listener(appForegrounded)
+  }
+  const after = isPhoneActive()
+  if (after === before) return
+  for (const listener of Array.from(listeners)) listener(after)
+}
+
+/**
+ * A suspended app misses lock events, so the state is re-read whenever the
+ * app changes foreground state, not only at start.
+ */
+function refreshLockState(): void {
+  void Promise.resolve(CrustModule.getPhoneLockState())
+    .then((state) => {
+      if (started) update({lock: state})
+    })
+    .catch((err: unknown) => console.warn(`PhoneActivity: getPhoneLockState failed: ${(err as Error)?.message ?? err}`))
+}
+
+export function startPhoneActivityTracking(): void {
+  if (started) return
+  started = true
+  appForegrounded = AppState.currentState === "active"
+  lockStateSubscription = CrustModule.addListener("phone_lock_state", (state: PhoneLockState) => update({lock: state}))
+  appStateSubscription = AppState.addEventListener("change", (next: AppStateStatus) => {
+    update({foregrounded: next === "active"})
+    refreshLockState()
+  })
+  refreshLockState()
+}
+
+export function stopPhoneActivityTracking(): void {
+  started = false
+  lockStateSubscription?.remove()
+  lockStateSubscription = null
+  appStateSubscription?.remove()
+  appStateSubscription = null
+  phoneLock = ASSUMED_LOCKED
+  appForegrounded = false
+  foregroundListeners.clear()
+}

package/src/services/PhoneCameraFovCoordinator.ts

@@ -1,5 +1,7 @@
 import BluetoothSdk, {type CameraFovRequest, type CameraFovResult} from "@glassly/bluetooth-sdk/internal"
 
+import {BgTimer} from "../utils/timers"
+
 export const CAMERA_FOV_OVERRIDE_TTL_MS = 300_000
 export const CAMERA_FOV_OVERRIDE_REFRESH_MS = 120_000
 // Legacy ASG clients restart the camera HAL for an FOV update but cannot acknowledge
@@ -36,7 +38,7 @@ export class PhoneCameraFovCoordinator {
   private effectiveLeaseId: string | undefined
   private sequence = 0
   private queue: Promise<unknown> = Promise.resolve()
-  private refreshTimer: ReturnType<typeof setTimeout> | undefined
+  private refreshTimer: number | undefined
   private legacyMode = false
 
   constructor(private readonly legacyRestartSettleMs = LEGACY_CAMERA_RESTART_SETTLE_MS) {}
@@ -147,7 +149,7 @@ export class PhoneCameraFovCoordinator {
     this.clearRefresh()
     const leaseId = this.effectiveLeaseId
     if (!leaseId) return
-    this.refreshTimer = setTimeout(() => {
+    this.refreshTimer = BgTimer.setTimeout(() => {
       void this.enqueue(async () => {
         if (this.effectiveLeaseId !== leaseId) return
         const entry = [...this.overrides.values()].find((candidate) => candidate.leaseId === leaseId)
@@ -164,7 +166,7 @@ export class PhoneCameraFovCoordinator {
   }
 
   private clearRefresh(): void {
-    if (this.refreshTimer) clearTimeout(this.refreshTimer)
+    if (this.refreshTimer) BgTimer.clearTimeout(this.refreshTimer)
     this.refreshTimer = undefined
   }
 
@@ -194,7 +196,7 @@ export class PhoneCameraFovCoordinator {
 
   private waitForLegacyCameraRestart(): Promise<void> {
     if (this.legacyRestartSettleMs <= 0) return Promise.resolve()
-    return new Promise<void>((resolve) => setTimeout(resolve, this.legacyRestartSettleMs))
+    return new Promise<void>((resolve) => BgTimer.setTimeout(resolve, this.legacyRestartSettleMs))
   }
 
   private enqueue<T>(operation: () => Promise<T>): Promise<T> {