@glassly/engine 0.3.0-dev.460 → 0.3.0-dev.465

package/src/services/pages/overlayApps.ts

@@ -1,51 +1,71 @@
 /**
- * The overlay apps: the connected miniapps whose manifest type is
- * "system_dashboard" (the dashboard). They alone may take the overlay slot
- * through `session.display.showView("dashboard")` and have "dashboard" in
- * their `display.views` capability while the glasses are eligible. The runtime adds an app when it connects and
- * removes it when it stops; the engine never knows what any of them draws.
- * Kept free of imports so the runtime and the notification policy can both
- * read it without a cycle.
+ * The overlay app: the connected miniapp that holds the dashboard role
+ * (ADR-0009). It alone may take the overlay slot through
+ * `session.display.showView("dashboard")` and has "dashboard" in its
+ * `display.views` capability while the glasses are eligible. The runtime
+ * records each dashboard miniapp (manifest type "dashboard") as it connects
+ * and stops, and who holds the role; the engine never knows what a dashboard
+ * draws. Kept free of imports so the runtime and the notification policy can
+ * both read it without a cycle.
  */
 
 export type DisplayView = "main" | "dashboard"
 
-const apps = new Set<string>()
-/** Overlay apps listening to the phone's notifications: something on the glasses presents them. */
-const viewers = new Set<string>()
+/** Connected dashboard miniapps, role or not. */
+const connected = new Set<string>()
+/** Connected dashboards listening to the phone's notifications. */
+const listening = new Set<string>()
+let active: string | null = null
 const listeners = new Set<() => void>()
 
+/** `packageName` holds the dashboard role and is connected. */
 export function isOverlayApp(packageName: string): boolean {
-  return apps.has(packageName)
+  return packageName === active && connected.has(packageName)
+}
+
+/** `packageName` is a connected dashboard miniapp, whether or not it holds the role. */
+export function isDashboardApp(packageName: string): boolean {
+  return connected.has(packageName)
 }
 
 export function overlayApps(): readonly string[] {
-  return [...apps]
+  return active !== null && connected.has(active) ? [active] : []
+}
+
+/** The package that holds the dashboard role, connected or not. */
+export function activeDashboard(): string | null {
+  return active
+}
+
+export function setActiveDashboard(packageName: string | null): void {
+  if (active === packageName) return
+  active = packageName
+  emit()
 }
 
-export function addOverlayApp(packageName: string): void {
-  if (apps.has(packageName)) return
-  apps.add(packageName)
+export function addDashboardApp(packageName: string): void {
+  if (connected.has(packageName)) return
+  connected.add(packageName)
   emit()
 }
 
-export function removeOverlayApp(packageName: string): void {
-  viewers.delete(packageName)
-  if (!apps.delete(packageName)) return
+export function removeDashboardApp(packageName: string): void {
+  listening.delete(packageName)
+  if (!connected.delete(packageName)) return
   emit()
 }
 
-/** Record whether an overlay app subscribes to phone notifications (it is a viewer while it does). */
-export function setOverlayViewer(packageName: string, listening: boolean): void {
-  const was = viewers.has(packageName)
-  if (listening && apps.has(packageName)) viewers.add(packageName)
-  else viewers.delete(packageName)
-  if (was !== viewers.has(packageName)) emit()
+/** Record whether a dashboard subscribes to phone notifications (the overlay app is the viewer while it does). */
+export function setOverlayViewer(packageName: string, subscribed: boolean): void {
+  const was = overlayViewerRunning()
+  if (subscribed && connected.has(packageName)) listening.add(packageName)
+  else listening.delete(packageName)
+  if (was !== overlayViewerRunning()) emit()
 }
 
-/** An overlay app that presents phone notifications is running. */
+/** The overlay app presents phone notifications. */
 export function overlayViewerRunning(): boolean {
-  return viewers.size > 0
+  return active !== null && connected.has(active) && listening.has(active)
 }
 
 export function onOverlayAppsChange(listener: () => void): () => void {
@@ -55,9 +75,9 @@ export function onOverlayAppsChange(listener: () => void): () => void {
   }
 }
 
-/** The views `packageName` may draw: main for everyone, the dashboard for overlay apps on eligible glasses. */
+/** The views `packageName` may draw: main for everyone, the dashboard for the overlay app on eligible glasses. */
 export function displayViewsFor(packageName: string, eligible: boolean): DisplayView[] {
-  return apps.has(packageName) && eligible ? ["main", "dashboard"] : ["main"]
+  return isOverlayApp(packageName) && eligible ? ["main", "dashboard"] : ["main"]
 }
 
 function emit(): void {
@@ -66,6 +86,7 @@ function emit(): void {
 
 /** Tests only. */
 export function _resetOverlayAppsForTest(): void {
-  apps.clear()
-  viewers.clear()
+  connected.clear()
+  listening.clear()
+  active = null
 }

package/src/services/settingsBridge.ts

@@ -1,28 +1,23 @@
 /**
  * The settings bridge's vocabulary (session.settings): which engine settings
- * a system miniapp may read or write, the derived read-only keys the engine
- * computes rather than stores, and the request validation. Pure, so the
- * runtime's handlers stay thin and this can be tested without the native
- * import surface the runtime pulls in.
+ * a miniapp with the PLATFORM_SETTINGS permission may read or write, the
+ * derived read-only keys the engine computes rather than stores, and the
+ * request validation. Pure, so the runtime's handlers stay thin and this can
+ * be tested without the native import surface the runtime pulls in.
  *
- * The dashboard miniapp is the consumer: it edits the same dashboard,
- * notification and glasses-menu keys the phone's settings screens used to,
- * through the store, so persistence, server sync and the Bluetooth sync of
- * `menu_apps` behave as if a phone screen wrote them.
+ * A dashboard miniapp is the usual consumer: it edits the notification and
+ * glasses-menu keys the phone's settings screens used to, through the store,
+ * so persistence, server sync and the Bluetooth sync of `menu_apps` behave as
+ * if a phone screen wrote them. A dashboard's own look is not here; it keeps
+ * that in its storage.
  */
 
 export type SettingsBridgeAccess = "read" | "write"
 
-/** Stored settings the bridge serves, by key, with what a system app may do to each. */
+/** Stored settings the bridge serves, by key, with what a permitted app may do to each. */
 export const SETTINGS_BRIDGE_KEYS: Readonly<Record<string, SettingsBridgeAccess>> = {
   // The dashboard's master switch is a phone-side debug knob.
   custom_dashboard_enabled: "read",
-  custom_dashboard_clock_style: "write",
-  custom_dashboard_clock_show_date: "write",
-  custom_dashboard_battery_style: "write",
-  custom_dashboard_layout: "write",
-  custom_dashboard_calendar_event_count: "write",
-  custom_dashboard_calendar_days_ahead: "write",
   contextual_dashboard: "write",
   twelve_hour_time: "write",
   menu_apps: "write",
@@ -38,18 +33,23 @@ export const SETTINGS_BRIDGE_KEYS: Readonly<Record<string, SettingsBridgeAccess>
 
 /**
  * Read-only keys the engine computes: whether the wearer can see the phone,
- * whether the foreground miniapp is drawing on the glasses, and the ring's
- * battery. They change on their own clocks; the runtime pushes them like
- * stored keys.
+ * whether the foreground miniapp is drawing on the glasses, the ring's
+ * battery, and the package that holds the dashboard role (null for nobody).
+ * They change on their own clocks; the runtime pushes them like stored keys.
  */
-export const DERIVED_SETTINGS_KEYS = ["phone_active", "foreground_app_on_screen", "ring_battery"] as const
+export const DERIVED_SETTINGS_KEYS = [
+  "phone_active",
+  "foreground_app_on_screen",
+  "ring_battery",
+  "active_dashboard",
+] as const
 export type DerivedSettingsKey = (typeof DERIVED_SETTINGS_KEYS)[number]
 
 export function isDerivedSettingsKey(key: string): key is DerivedSettingsKey {
   return (DERIVED_SETTINGS_KEYS as readonly string[]).includes(key)
 }
 
-/** What a system app may do with `key`, or null when the bridge does not serve it. */
+/** What a permitted app may do with `key`, or null when the bridge does not serve it. */
 export function settingsBridgeAccess(key: string): SettingsBridgeAccess | null {
   if (isDerivedSettingsKey(key)) return "read"
   return SETTINGS_BRIDGE_KEYS[key] ?? null

package/src/stores/apps.ts

@@ -25,6 +25,7 @@ import {islandNotifications} from "../services/NotificationsEmitter"
 import sttModelManager from "../services/STTModelManager"
 import {miniappLauncher} from "../services/MiniappLauncher"
 import {miniappRunningRegistry} from "../services/MiniappRunningRegistry"
+import {activeDashboardAmong, resolveActiveDashboard} from "../services/pages/activeDashboard"
 import {defaultHiddenStatus, isGatedByDevTools, isGatedUntilPaired, resolveHiddenStatus} from "./appVisibility"
 import {SETTINGS, useSettingsStore} from "./settings"
 import {PermissionFeatures, permissions} from "../facades/permissions"
@@ -102,6 +103,7 @@ interface AppStatusState {
    * off leaves it running. Persists the wearer's choice beside the hidden flag.
    */
   setAlwaysOn: (packageName: string, status: boolean) => Promise<void>
+  setActiveDashboard: (packageName: string) => Promise<void>
   /** Replace the whole apps array. Hosts use this when their extra source changes. */
   setApps: (apps: ClientApp[]) => void
 }
@@ -512,9 +514,17 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
 
   uninstall: (packageName, version) => {
     return Res.try_async(async () => {
+      const wasActiveDashboard = activeDashboardAmong(get().apps) === packageName
       const res = await appRegistry.uninstall(packageName, version)
       if (res.is_error()) throw res.error
       set((s) => ({apps: s.apps.filter((a) => a.packageName !== packageName)}))
+      // The dashboard role fell back to another dashboard, which was stopped
+      // when it lost the role: start it, as launch would have.
+      if (wasActiveDashboard) {
+        const apps = get().apps
+        const heir = apps.find((a) => a.packageName === activeDashboardAmong(apps))
+        if (heir?.alwaysOn && !heir.running) await get().start(heir, {skipNavigation: true})
+      }
     })
   },
 
@@ -559,6 +569,18 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
     if (status && !app.running) await get().start(app, {skipNavigation: true})
   },
 
+  // The dashboard role (ADR-0009) moves to `packageName`: the previous holder
+  // stops and the new one starts in the background.
+  setActiveDashboard: async (packageName: string) => {
+    const apps = get().apps
+    const next = apps.find((a) => a.packageName === packageName && a.type === "dashboard")
+    if (!next) return
+    const previous = apps.find((a) => a.packageName === activeDashboardAmong(apps))
+    await useSettingsStore.getState().setSetting(SETTINGS.active_dashboard.key, packageName)
+    if (previous?.running && previous.packageName !== packageName) await get().stop(previous.packageName)
+    if (!next.running) await get().start(next, {skipNavigation: true})
+  },
+
   setApps: (apps) => set({apps}),
 }))
 
@@ -665,8 +687,28 @@ export const useRunningAlwaysOnApps = () => {
   return useMemo(() => apps.filter((app) => app.alwaysOn && 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"
+/** Installed miniapps that can hold the dashboard role: manifest type "dashboard". */
+export const useDashboards = () => {
+  const apps = useApps()
+  return useMemo(() => apps.filter((app) => app.type === "dashboard"), [apps])
+}
+
+/** The miniapp that holds the dashboard role (ADR-0009), or null when none is installed. */
+export const useActiveDashboard = (): ClientApp | null => {
+  const dashboards = useDashboards()
+  const chosen = useSettingsStore((s) => s.getSetting(SETTINGS.active_dashboard.key))
+  return useMemo(() => {
+    const packageName = resolveActiveDashboard(
+      dashboards.map((app) => app.packageName),
+      chosen,
+      SETTINGS.active_dashboard.defaultValue(),
+    )
+    return dashboards.find((app) => app.packageName === packageName) ?? null
+  }, [dashboards, chosen])
+}
+
+/** Apps that run without a foreground surface: background ones and dashboards. */
+const isBackgroundApp = (app: ClientApp): boolean => app.type === "background" || app.type === "dashboard"
 
 export const useActiveBackgroundApps = () => {
   const apps = useApps()

package/src/stores/settings.ts

@@ -794,51 +794,12 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: false,
     persist: true,
   },
-  // Device-local preferences for the Scene API dashboard available on G2
-  // custom firmware. Eligibility is firmware-reported at runtime, so there is
-  // deliberately no enable toggle: eligible devices replace the native
-  // dashboard automatically while stock firmware keeps its native dashboard.
-  custom_dashboard_clock_style: {
-    key: "custom_dashboard_clock_style",
-    defaultValue: () => "compact",
-    writable: true,
-    saveOnServer: false,
-    persist: true,
-  },
-  custom_dashboard_clock_show_date: {
-    key: "custom_dashboard_clock_show_date",
-    defaultValue: () => true,
-    writable: true,
-    saveOnServer: false,
-    persist: true,
-  },
-  // "solid" | "two_tone": the battery widgets' G and R.
-  custom_dashboard_battery_style: {
-    key: "custom_dashboard_battery_style",
-    defaultValue: () => "solid",
-    writable: true,
-    saveOnServer: false,
-    persist: true,
-  },
-  // {preset, slots: {slotId: widgetId}, scratchpad: [widgetId]} — the
-  // dashboard miniapp owns the shape and its default; null draws its default layout.
-  custom_dashboard_layout: {
-    key: "custom_dashboard_layout",
-    defaultValue: () => null,
-    writable: true,
-    saveOnServer: false,
-    persist: true,
-  },
-  custom_dashboard_calendar_event_count: {
-    key: "custom_dashboard_calendar_event_count",
-    defaultValue: () => 3,
-    writable: true,
-    saveOnServer: false,
-    persist: true,
-  },
-  custom_dashboard_calendar_days_ahead: {
-    key: "custom_dashboard_calendar_days_ahead",
-    defaultValue: () => 5,
+  // The wearer's choice of dashboard miniapp (ADR-0009). Installs are
+  // per-phone, so the choice is device-local. The default is the bundled
+  // dashboard, which the role falls back to when the choice is not installed.
+  active_dashboard: {
+    key: "active_dashboard",
+    defaultValue: () => "com.glassly.dashboard",
     writable: true,
     saveOnServer: false,
     persist: true,

package/src/types/applet.ts

@@ -10,7 +10,7 @@ import type {CompatibilityResult} from "../utils/hardware/hardware"
 /**
  * App execution model types
  */
-export type AppletType = "standard" | "background" | "system_dashboard"
+export type AppletType = "standard" | "background" | "dashboard"
 
 /**
  * Permission types that apps can request
@@ -29,6 +29,8 @@ export type AppPermissionType =
   | "MEMORY"
   | "AI"
   | "SPEAKERS"
+  | "MANAGE_MINIAPPS"
+  | "PLATFORM_SETTINGS"
 
 /**
  * Permission object with type and description