@glassly/engine 0.3.5-beta.788 → 0.3.5-beta.795

package/src/services/AppRegistry.ts

@@ -22,7 +22,7 @@ import {unzip} from "react-native-zip-archive"
 import semver from "semver"
 import {AsyncResult, Result, result as Res} from "typesafe-ts"
 
-import type {AppletPermission, AppPermissionType, AppletType, ClientApp} from "../types/applet"
+import type {AppletPermission, AppPermissionType, AppletType, ClientApp, DeclaredWidget} from "../types/applet"
 import {HardwareRequirement, HardwareRequirementLevel, HardwareType} from "../types"
 import {configuredDevHost} from "../utils/configuredDevHost"
 import {storage} from "../utils/storage/storage"
@@ -776,7 +776,7 @@ class AppRegistry {
 
         // Declared actions (for session.miniapps.list + invoke gating).
         const actions = normalizeManifestActions(manifest?.actions)
-        const widgets = normalizeManifestWidgets(manifest?.widgets)
+        const widgets = withWidgetExpandChoices(lmaInfo.packageName, normalizeManifestWidgets(manifest?.widgets))
 
         // Dev miniapps live in the same lmas/ tree as installed ones, but
         // their version directory name starts with "dev-".
@@ -864,7 +864,9 @@ class AppRegistry {
         permissions,
         hardwareRequirements,
         actions: normalizeManifestActions(rec.actions),
-        ...(normalizeManifestWidgets(rec.widgets).length > 0 ? {widgets: normalizeManifestWidgets(rec.widgets)} : {}),
+        ...(normalizeManifestWidgets(rec.widgets).length > 0
+          ? {widgets: withWidgetExpandChoices(rec.packageName, normalizeManifestWidgets(rec.widgets))}
+          : {}),
         isMiniappDev: true,
         devUrl: rec.devUrl,
         devPort: rec.devPort,
@@ -948,6 +950,19 @@ export function saveAlwaysOnOverride(packageName: string, status: boolean): void
   storage.save(`${packageName}_always_on`, status)
 }
 
+/** Applies the wearer's tap-to-expand choice to each expandable widget; expansion is on until they turn it off. */
+export function withWidgetExpandChoices(packageName: string, widgets: DeclaredWidget[]): DeclaredWidget[] {
+  return widgets.map((widget) => {
+    if (!widget.expandable) return widget
+    const res = storage.load<boolean>(`${packageName}_widget_expand_${widget.id}`)
+    return {...widget, expandOnTap: res.is_ok() ? res.value !== false : true}
+  })
+}
+
+export function saveWidgetExpandChoice(packageName: string, widgetId: string, expandOnTap: boolean): void {
+  storage.save(`${packageName}_widget_expand_${widgetId}`, expandOnTap)
+}
+
 export function getLocalAppScreenshot(packageName: string): string | undefined {
   const key = `${packageName}_screenshot`
   const res = storage.load<string>(key)

package/src/services/GlassesTouchInput.ts

@@ -107,12 +107,13 @@ export function dispatchTouchEvent(event: TouchEvent): void {
 function routeTouchEvent(event: TouchEvent): void {
   const gesture = event.gestureName
   const claimant = localMiniappRuntime.gestureClaimant(gesture)
-  // The Neural Band's middle finger (index 1) shares the tap names but is left
-  // to miniapps: the engine's own double-tap behaviors are the index finger's.
-  const osDoubleTap = gesture === "double_tap" && event.index !== 1
+  const doubleTap = gesture === "double_tap"
+  // The Neural Band's middle finger (index 1) shares the tap names. Either
+  // finger leaves the app on screen; the firmware dashboard is the index finger's.
+  const osDoubleTap = doubleTap && event.index !== 1
   const osHeadUp = gesture === "head_up"
 
-  if (osDoubleTap) {
+  if (doubleTap) {
     // The app being left opts out of OS exit by registering double tap (the
     // terminal's back-to-menu). The latest claimant still receives it. Otherwise
     // the tap means "leave the app". The controller shows the bounded OS

package/src/services/LocalMiniappRuntime.ts

@@ -1824,6 +1824,9 @@ class LocalMiniappRuntime {
       case MiniappRequestType.WIDGET_RESULT:
         this.handleWidgetResult(packageName, payload)
         break
+      case MiniappRequestType.WIDGET_EXPANDABLE:
+        this.handleWidgetExpandable(packageName, payload, requestId)
+        break
       case MiniappRequestType.SYSTEM_EXIT:
         void this.handleSystemExit(packageName, requestId)
         break
@@ -6063,6 +6066,8 @@ class LocalMiniappRuntime {
   private async startInteropApp(packageName: string): Promise<boolean> {
     const app = this.interopApps().find((a) => a.packageName === packageName)
     if (!app) return false
+    // Running only for its widget: start() promotes it to a normal run, as opening it on the phone does.
+    if (app.widgetOnly) return useAppStatusStore.getState().start(app, {skipNavigation: true})
     if (app.local) {
       await miniappLauncher.ensureConnected(packageName)
       return true
@@ -6124,7 +6129,8 @@ class LocalMiniappRuntime {
       packageName: app.packageName,
       name: app.name,
       version: app.version ?? "",
-      running: app.running,
+      // A provider running only for a placed widget is not a run the wearer started.
+      running: app.running && !app.widgetOnly,
       hidden: app.hidden === true,
       system: isSystemMiniapp(app),
       compatibility,
@@ -6368,7 +6374,7 @@ class LocalMiniappRuntime {
           name: widget.name,
           sizes: widget.sizes,
           defaultSize: widget.defaultSize,
-          expandable: widget.expandable,
+          expandable: widget.expandOnTap,
           running: app.running,
           compatible: app.compatibility?.isCompatible !== false,
         })
@@ -6577,6 +6583,25 @@ class LocalMiniappRuntime {
     }
   }
 
+  /** Provider: read, or set with `expandable`, whether a tap expands one of its own `EX` widgets. */
+  private handleWidgetExpandable(packageName: string, payload: Record<string, unknown>, requestId?: string): void {
+    const widgetId = payload.widgetId as string | undefined
+    const app = this.interopApps().find((a) => a.packageName === packageName)
+    const widget = app && widgetId ? this.declaredWidget(app, widgetId) : undefined
+    if (!widget?.expandable) {
+      this.sendResult(packageName, requestId, false, undefined, {
+        code: MiniappErrorCode.WIDGET_NOT_FOUND,
+        message: `${packageName} has no widget "${widgetId ?? "(missing widgetId)"}" that lists EX`,
+      })
+      return
+    }
+    const expandable =
+      typeof payload.expandable === "boolean"
+        ? useAppStatusStore.getState().setWidgetExpand(packageName, widget.id, payload.expandable)
+        : widget.expandOnTap
+    this.sendResult(packageName, requestId, true, {expandable})
+  }
+
   /** Provider → host, one-shot: cache the frame for its view and push it to every host holding the widget. */
   private handleWidgetUpdate(providerPackageName: string, payload: Record<string, unknown>): void {
     const widgetId = payload.widgetId as string | undefined
@@ -6588,7 +6613,7 @@ class LocalMiniappRuntime {
     const view: WidgetView = payload.view === "expanded" ? "expanded" : "card"
     if (view === "expanded" && !widget.expandable) {
       console.warn(
-        `${LOG_TAG}: dropping expanded frame from ${providerPackageName}/${widgetId}: not declared expandable`,
+        `${LOG_TAG}: dropping expanded frame from ${providerPackageName}/${widgetId}: it does not list EX`,
       )
       return
     }

package/src/services/manifestActions.ts

@@ -84,9 +84,11 @@ const isWidgetSize = (value: unknown): value is DeclaredWidgetSize => (WIDGET_SI
 
 /**
  * Normalize manifest widgets for installed and dev-sideloaded bundles: an
- * entry without an id, a name or a usable size is dropped, repeats of a
+ * entry without an id, a name or a usable card size is dropped, repeats of a
  * size are folded, and a default size the widget does not offer becomes
- * its first size. Only `expandable: true` makes a widget expandable.
+ * its first size. Listing `EX` makes a widget expandable; it is not a card
+ * size. Taps expand it until the wearer turns that off (AppRegistry applies
+ * the choice).
  */
 export function normalizeManifestWidgets(raw: unknown): DeclaredWidget[] {
   if (!Array.isArray(raw)) return []
@@ -103,12 +105,15 @@ export function normalizeManifestWidgets(raw: unknown): DeclaredWidget[] {
     const sizes = Array.isArray(w.sizes) ? Array.from(new Set(w.sizes.filter(isWidgetSize))) : []
     if (sizes.length === 0) continue
     seen.add(w.id)
+    // `expandable: true` is how bundles from before `EX` said the same.
+    const expandable = (Array.isArray(w.sizes) && w.sizes.includes("EX")) || w.expandable === true
     out.push({
       id: w.id,
       name: w.name,
       sizes,
       defaultSize: isWidgetSize(w.defaultSize) && sizes.includes(w.defaultSize) ? w.defaultSize : sizes[0],
-      expandable: w.expandable === true,
+      expandable,
+      expandOnTap: expandable,
     })
   }
   return out

package/src/stores/apps.ts

@@ -19,7 +19,7 @@ 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, {saveAlwaysOnOverride} from "../services/AppRegistry"
+import appRegistry, {saveAlwaysOnOverride, saveWidgetExpandChoice} from "../services/AppRegistry"
 import localDisplayManager from "../services/LocalDisplayManager"
 import {islandNotifications} from "../services/NotificationsEmitter"
 import sttModelManager from "../services/STTModelManager"
@@ -103,6 +103,12 @@ interface AppStatusState {
    * off leaves it running. Persists the wearer's choice beside the hidden flag.
    */
   setAlwaysOn: (packageName: string, status: boolean) => Promise<void>
+  /**
+   * Whether a tap on one of the miniapp's dashboard widgets expands it to the
+   * full screen. Only widgets that list `EX` expand; false for the rest.
+   * Persists the choice and answers the setting now in force.
+   */
+  setWidgetExpand: (packageName: string, widgetId: string, expandOnTap: boolean) => boolean
   /** Replace the whole apps array. Hosts use this when their extra source changes. */
   setApps: (apps: ClientApp[]) => void
 }
@@ -587,6 +593,22 @@ export const useAppStatusStore = create<AppStatusState>((set, get) => ({
     if (status && !app.running) await get().start(app, {skipNavigation: true})
   },
 
+  setWidgetExpand: (packageName, widgetId, expandOnTap) => {
+    const app = get().apps.find((a) => a.packageName === packageName)
+    const widget = app?.widgets?.find((w) => w.id === widgetId)
+    if (!widget?.expandable) return false
+    if (widget.expandOnTap === expandOnTap) return expandOnTap
+    saveWidgetExpandChoice(packageName, widgetId, expandOnTap)
+    set((s) => ({
+      apps: s.apps.map((a) =>
+        a.packageName === packageName
+          ? {...a, widgets: a.widgets?.map((w) => (w.id === widgetId ? {...w, expandOnTap} : w))}
+          : a,
+      ),
+    }))
+    return expandOnTap
+  },
+
   setApps: (apps) => set({apps}),
 }))
 

package/src/types/applet.ts

@@ -97,8 +97,10 @@ export interface DeclaredWidget {
   name: string
   sizes: DeclaredWidgetSize[]
   defaultSize: DeclaredWidgetSize
-  /** A tap on the selected widget expands it to the full screen instead of activating the card. */
+  /** Lists the `EX` size: a tap on the selected widget can expand it to the full screen. */
   expandable: boolean
+  /** A tap expands it rather than activating the card: expandable, and the wearer left expansion on. */
+  expandOnTap: boolean
 }
 
 export interface ClientApp extends AppletInterface {