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

package/src/stores/apps.ts

@@ -19,15 +19,17 @@ import {DeviceTypes} from "../types/enums"
 import {getModelCapabilities} from "../types/hardware"
 import {HardwareCompatibility, type CompatibilityResult} from "../utils/hardware/hardware"
 import {storage} from "../utils/storage/storage"
-import appRegistry from "../services/AppRegistry"
+import appRegistry, {savePersistentOverride} from "../services/AppRegistry"
 import localDisplayManager from "../services/LocalDisplayManager"
 import {islandNotifications} from "../services/NotificationsEmitter"
 import sttModelManager from "../services/STTModelManager"
 import {miniappLauncher} from "../services/MiniappLauncher"
 import {miniappRunningRegistry} from "../services/MiniappRunningRegistry"
-import {resolveHiddenStatus} from "./appVisibility"
+import {defaultHiddenStatus, isGatedByDevTools, isGatedUntilPaired, resolveHiddenStatus} from "./appVisibility"
 import {SETTINGS, useSettingsStore} from "./settings"
+import {PermissionFeatures, permissions} from "../facades/permissions"
 import BluetoothSdk from "@glassly/bluetooth-sdk"
+import type {MiniappLaunchSource} from "@glassly/miniapp"
 
 // ---------------------------------------------------------------------------
 // Configuration / hooks
@@ -35,6 +37,8 @@ import BluetoothSdk from "@glassly/bluetooth-sdk"
 
 export interface StartOptions {
   skipNavigation?: boolean
+  /** Reported to the miniapp on connect. Defaults to "phone". */
+  launchSource?: MiniappLaunchSource
 }
 
 export interface AppStoreHooks {
@@ -91,6 +95,13 @@ interface AppStatusState {
   saveScreenshot: (packageName: string, screenshot: string) => Promise<void>
   setHiddenStatus: (packageName: string, status: boolean) => void
   getHiddenStatus: (packageName: string) => boolean
+  /**
+   * Mark a miniapp persistent: it starts at launch and only stops from the
+   * app switcher's persistent pill (its card cannot be swiped away and the
+   * capsule close minimizes it). Turning it on starts the app; turning it
+   * off leaves it running. Persists the wearer's choice beside the hidden flag.
+   */
+  setPersistent: (packageName: string, status: boolean) => Promise<void>
   /** Replace the whole apps array. Hosts use this when their extra source changes. */
   setApps: (apps: ClientApp[]) => void
 }
@@ -198,6 +209,8 @@ function projectApps(previousState: AppStatusState, localApps: ClientApp[]): Cli
     (useSettingsStore.getState().getSetting(SETTINGS.default_wearable.key) as DeviceTypes | undefined) ||
     DeviceTypes.NONE
   const capabilities = getModelCapabilities(defaultWearable)
+  const devToolsEnabled = useSettingsStore.getState().getSetting(SETTINGS.dev_tools.key) === true
+  const hasPairedGlasses = useSettingsStore.getState().getSetting(SETTINGS.has_paired_glasses.key) === true
 
   // Single pass: dedupe → screenshot carry-over → compat → hidden, all into
   // fresh objects. The previous in-place mutation re-used object references
@@ -217,29 +230,34 @@ function projectApps(previousState: AppStatusState, localApps: ClientApp[]): Cli
   // nothing meaningful changed. Same pattern as the miniappRunningRegistry
   // projection below. A stable foreground-app reference lets the Compositor's
   // slide run uninterrupted on the UI thread.
-  return Array.from(byPackage.values()).map((app) => {
-    const next: ClientApp = {
-      ...app,
-      screenshot: previousByPackage.get(app.packageName)?.screenshot ?? app.screenshot,
-      compatibility: HardwareCompatibility.checkCompatibility(app.hardwareRequirements, capabilities),
-      // A registry source can force an app off the primary home screen (for
-      // example, Miniapp Developer while its home-screen setting is disabled).
-      // Compose that gate with the user's persisted home-screen layout instead
-      // of replacing it, otherwise a default-false persisted value makes a
-      // source-hidden app visible again during projection.
-      hidden: resolveHiddenStatus(app.hidden, previousState.getHiddenStatus(app.packageName)),
-      // Derive the foreground flag from the store's single source of truth
-      // (`foregroundedPackage`), NOT from the previous snapshot. Carrying it over
-      // per-app meant a refresh that momentarily omitted an app (e.g. the
-      // two-pass local-only → merged emit) would reset its flag to false — which
-      // raced OfflineAppHost's interceptor guard and made the hosted miniapp fall
-      // through to the root router (restart). Deriving here keeps the flag stable
-      // across both passes.
-      foregrounded: app.packageName === previousState.foregroundedPackage,
-    }
-    const prev = previousByPackage.get(app.packageName)
-    return prev && shallowEqualApp(prev, next) ? prev : next
-  })
+  return Array.from(byPackage.values())
+    .filter(
+      (app) =>
+        !isGatedByDevTools(app.packageName, devToolsEnabled) &&
+        !isGatedUntilPaired(app.packageName, devToolsEnabled, hasPairedGlasses),
+    )
+    .map((app) => {
+      const next: ClientApp = {
+        ...app,
+        screenshot: previousByPackage.get(app.packageName)?.screenshot ?? app.screenshot,
+        compatibility: HardwareCompatibility.checkCompatibility(app.hardwareRequirements, capabilities),
+        // A registry source can force an app off the primary home screen.
+        // Compose that gate with the user's persisted home-screen layout instead
+        // of replacing it, otherwise a default-false persisted value makes a
+        // source-hidden app visible again during projection.
+        hidden: resolveHiddenStatus(app.hidden, previousState.getHiddenStatus(app.packageName)),
+        // Derive the foreground flag from the store's single source of truth
+        // (`foregroundedPackage`), NOT from the previous snapshot. Carrying it over
+        // per-app meant a refresh that momentarily omitted an app (e.g. the
+        // two-pass local-only → merged emit) would reset its flag to false — which
+        // raced OfflineAppHost's interceptor guard and made the hosted miniapp fall
+        // through to the root router (restart). Deriving here keeps the flag stable
+        // across both passes.
+        foregrounded: app.packageName === previousState.foregroundedPackage,
+      }
+      const prev = previousByPackage.get(app.packageName)
+      return prev && shallowEqualApp(prev, next) ? prev : next
+    })
 }
 
 // Cheap equality check used by projectApps to preserve object identity across
@@ -360,6 +378,11 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
       return true
     }
 
+    // The phone mic is asked for here, at first use, not during pairing: the
+    // OS prompt lands over the app that needs it. The facade returns at once
+    // when the answer is already known, so this only ever prompts once.
+    if (declaresMicrophone(app)) await permissions.request(PermissionFeatures.MICROPHONE)
+
     // Foreground-only-one rule: stop other running standard apps.
     if (app.type === "standard") {
       const runningForeground = state.apps.filter(
@@ -385,7 +408,7 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
     // (no JS bundle).
     if (app.local) {
       try {
-        await miniappLauncher.ensureRunning(packageName)
+        await miniappLauncher.ensureRunning(packageName, {launchSource: opts?.launchSource ?? "phone"})
       } catch (e) {
         // Spawn / bundle-resolve failed — revert the optimistic running flag so
         // the home list and miniapps.list() don't show a "running" app with no
@@ -477,7 +500,8 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
 
   stopAll: () => {
     return Res.try_async(async () => {
-      const running = get().apps.filter((a) => a.running)
+      // Persistent apps stay up; they stop one at a time from the switcher.
+      const running = get().apps.filter((a) => a.running && !a.persistent)
       for (const a of running) {
         await get().stop(a.packageName)
       }
@@ -520,11 +544,21 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
     const cached = hiddenStatusCache.get(packageName)
     if (cached !== undefined) return cached
     const res = storage.load<boolean>(`${packageName}_hidden`)
-    const value = res.is_ok() ? res.value : false
+    const value = res.is_ok() ? res.value : defaultHiddenStatus(packageName)
     hiddenStatusCache.set(packageName, value)
     return value
   },
 
+  setPersistent: async (packageName: string, status: boolean) => {
+    const app = get().apps.find((a) => a.packageName === packageName)
+    if (!app) return
+    savePersistentOverride(packageName, status)
+    set((s) => ({
+      apps: s.apps.map((a) => (a.packageName === packageName ? {...a, persistent: status} : a)),
+    }))
+    if (status && !app.running) await get().start(app, {skipNavigation: true})
+  },
+
   setApps: (apps) => set({apps}),
 }))
 
@@ -571,6 +605,40 @@ useSettingsStore.subscribe(
   },
 )
 
+// Developer tools toggled: dev-only apps enter or leave the projection. When
+// they leave, stop any that are running first so the running registry doesn't
+// keep a miniapp alive that no launcher surface can reach.
+useSettingsStore.subscribe(
+  (state) => state.getSetting(SETTINGS.dev_tools.key) === true,
+  (enabled) => {
+    void (async () => {
+      if (!enabled) {
+        const state = useAppStatusStore.getState()
+        const hasPairedGlasses = useSettingsStore.getState().getSetting(SETTINGS.has_paired_glasses.key) === true
+        for (const app of state.apps) {
+          const gated =
+            isGatedByDevTools(app.packageName, false) || isGatedUntilPaired(app.packageName, false, hasPairedGlasses)
+          if (app.running && gated) await state.stop(app.packageName)
+        }
+      }
+      await useAppStatusStore.getState().refresh()
+    })()
+  },
+)
+
+// First real pairing latched: the Store enters the projection. One-way, so
+// nothing ever leaves here.
+useSettingsStore.subscribe(
+  (state) => state.getSetting(SETTINGS.has_paired_glasses.key) === true,
+  () => {
+    void useAppStatusStore.getState().refresh()
+  },
+)
+
+/** Declares the microphone (or everything) in its manifest. */
+const declaresMicrophone = (app: ClientApp): boolean =>
+  app.permissions.some((p) => p.type === "MICROPHONE" || p.type === "ALL")
+
 // ---------------------------------------------------------------------------
 // Public hooks
 // ---------------------------------------------------------------------------
@@ -585,22 +653,32 @@ export const useStopAll = () => useAppStatusStore((state) => state.stopAll)
 export const useInstall = () => useAppStatusStore((state) => state.install)
 export const useUninstall = () => useAppStatusStore((state) => state.uninstall)
 
+/** Every running app; each one has a card in the app switcher tray. */
 export const useActiveApps = () => {
   const apps = useApps()
   return useMemo(() => apps.filter((app) => app.running), [apps])
 }
 
+/** Persistent apps whose background task is running, card or no card. */
+export const useRunningPersistentApps = () => {
+  const apps = useApps()
+  return useMemo(() => apps.filter((app) => app.persistent && app.running), [apps])
+}
+
+/** Apps that run without a foreground surface: background ones and the system dashboard. */
+const isBackgroundApp = (app: ClientApp): boolean => app.type === "background" || app.type === "system_dashboard"
+
 export const useActiveBackgroundApps = () => {
   const apps = useApps()
-  return useMemo(() => apps.filter((app) => app.type === "background" && app.running), [apps])
+  return useMemo(() => apps.filter((app) => isBackgroundApp(app) && app.running), [apps])
 }
 
 export const useBackgroundApps = () => {
   const apps = useApps()
   return useMemo(
     () => ({
-      active: apps.filter((app) => app.type === "background" && app.running),
-      inactive: apps.filter((app) => app.type === "background" && !app.running),
+      active: apps.filter((app) => isBackgroundApp(app) && app.running),
+      inactive: apps.filter((app) => isBackgroundApp(app) && !app.running),
     }),
     [apps],
   )
@@ -623,7 +701,7 @@ export const useForegroundApp = () => {
 
 export const useActiveBackgroundAppsCount = () => {
   const apps = useApps()
-  return useMemo(() => apps.filter((app) => app.type === "background" && app.running).length, [apps])
+  return useMemo(() => apps.filter((app) => isBackgroundApp(app) && app.running).length, [apps])
 }
 
 export const useLocalMiniApps = () => {

package/src/stores/bluetoothSettingKeys.ts

@@ -27,7 +27,7 @@ export const MENTRA_LIVE_SETTING_KEYS: string[] = [
 ]
 
 function isMentraLiveDevice(model: string | undefined): boolean {
-  return model === DeviceTypes.LIVE || model === "Mentra Live"
+  return model === DeviceTypes.LIVE
 }
 
 export function getBluetoothSettingKeysForDevice(deviceModel: string | undefined, fullKeys: string[]): string[] {

package/src/stores/display.ts

@@ -44,10 +44,10 @@ function applyDisplayEvent(set: (partial: Partial<DisplayStore>) => void, event:
 export interface DisplayStore {
   /** The frame currently on the glasses — the mirror renders this. */
   currentEvent: any
-  /** True while the dashboard covers the main content (see DashboardCoordinator). */
-  dashboardActive: boolean
+  /** The page (scene app id) holding the overlay slot over the main content, or null (see PageHost). */
+  overlayOwner: string | null
   setDisplayEvent: (event: DisplayEvent | string) => void
-  setDashboardActive: (active: boolean) => void
+  setOverlayOwner: (owner: string | null) => void
 }
 
 let pendingDisplayEvent: DisplayEvent | null = null
@@ -56,9 +56,20 @@ let displayCoalesceTimer: ReturnType<typeof BgTimer.setTimeout> | null = null
 export const useDisplayStore = create<DisplayStore>()(
   subscribeWithSelector((set) => ({
     currentEvent: {} as any,
-    dashboardActive: false,
+    overlayOwner: null,
     setDisplayEvent: (event: DisplayEvent | string) => {
       const parsed: DisplayEvent = typeof event === "string" ? JSON.parse(event) : event
+      const layoutType = (parsed.layout as {layoutType?: string} | undefined)?.layoutType
+      // Scenes are already paced by their producer. Caption coalescing drops
+      // video frames and can discard the starting pose of a short transition.
+      // A clear must also cancel any caption waiting to overwrite the display.
+      if (layoutType === "scene" || layoutType === "clear_view" || layoutType === "unavailable") {
+        if (displayCoalesceTimer) BgTimer.clearTimeout(displayCoalesceTimer)
+        displayCoalesceTimer = null
+        pendingDisplayEvent = null
+        applyDisplayEvent(set, parsed)
+        return
+      }
       pendingDisplayEvent = parsed
       if (displayCoalesceTimer) return
       displayCoalesceTimer = BgTimer.setTimeout(() => {
@@ -68,9 +79,9 @@ export const useDisplayStore = create<DisplayStore>()(
         if (next) applyDisplayEvent(set, next)
       }, DISPLAY_COALESCE_MS)
     },
-    setDashboardActive: (active: boolean) => {
-      logE2EMetric("display_view_changed", {view: active ? "dashboard" : "main"})
-      set({dashboardActive: active})
+    setOverlayOwner: (owner: string | null) => {
+      logE2EMetric("display_view_changed", {view: owner === null ? "main" : "dashboard"})
+      set({overlayOwner: owner})
     },
   })),
 )

package/src/stores/glasses.ts

@@ -11,6 +11,8 @@ import {isGlassesConnected, isGlassesLinkLayerBusy, isGlassesReady} from "../ser
 import {create} from "zustand"
 import {subscribeWithSelector} from "zustand/middleware"
 
+import {BgTimer} from "../utils/timers"
+
 // Re-export the connection predicates (single source of truth lives in
 // GlassesReadiness) so importers of this store keep getting them.
 export {isGlassesConnected, isGlassesLinkLayerBusy, isGlassesReady}
@@ -141,12 +143,17 @@ const initialState: GlassesStore = {
   hotspotOtaVersion: 0,
   sceneCanvasWidth: 0,
   sceneCanvasHeight: 0,
+  sceneVector: false,
+  sceneSettle: false,
   // wifi info
   wifi: {state: "disconnected"},
   wifiStatusKnown: false,
   // battery info
   batteryLevel: -1,
   charging: false,
+  ringConnected: false,
+  ringBatteryLevel: -1,
+  ringCharging: false,
   caseBatteryLevel: -1,
   caseCharging: false,
   caseOpen: false,
@@ -167,6 +174,13 @@ const initialState: GlassesStore = {
   controllerSignalStrength: -1,
   // iOS ANCS consent (G2 consumes notifications on-firmware):
   ancsAuthorized: false,
+  // G2 Glassly CFW keyboard bridge (revision 39+):
+  keyboardBridge: false,
+  keyboardConnected: false,
+  keyboardName: "",
+  keyboardSaved: false,
+  keyboardState: "idle",
+  keyboardError: "",
 }
 
 export const useGlassesStore = create<GlassesState>()(
@@ -315,7 +329,7 @@ export const waitForGlassesState = <K extends keyof GlassesState>(
       },
     )
 
-    setTimeout(() => {
+    BgTimer.setTimeout(() => {
       unsubscribe()
       resolve(predicate(useGlassesStore.getState()[key]))
     }, timeoutMs)