@glassly/engine 0.1.0-dev.1 → 0.1.0-dev.26

package/src/services/AppRegistry.ts

@@ -879,6 +879,22 @@ class AppRegistry {
     this.notify()
   }
 
+  /**
+   * Update whether a registered offline app is projected into launcher UIs.
+   *
+   * Offline apps are registered once at host startup, so settings-backed
+   * visibility changes need to update the projection without reinstalling or
+   * duplicating the app. No-op when the app is missing or already matches.
+   */
+  public setOfflineAppHidden(packageName: string, hidden: boolean): void {
+    const app = this.offlineApps.find((candidate) => candidate.packageName === packageName)
+    if (!app || app.hidden === hidden) return
+
+    app.hidden = hidden
+    this.refreshNeeded = true
+    this.notify()
+  }
+
   /**
    * Registered as needing the on-device STT model before it can start (the
    * host declares this per offline app; the apps store gates start() on it).

package/src/services/BlobStore.ts

@@ -40,8 +40,15 @@ const LOG_TAG = "LocalMiniappRuntime"
 /** Per-app blob quota: 1 GB. */
 export const BLOB_QUOTA_BYTES = 1024 * 1024 * 1024
 const ROOT_DIR_NAME = "glassly_blobs"
-/** Cache dir root holding short-lived, properly-named copies handed to the OS share sheet (one unique subdir per share). */
+/** Cache dir root holding short-lived, properly-named copies handed to the OS share sheet (one subdir per stored blob). */
 const SHARE_DIR_NAME = "blob_share"
+/**
+ * Keep prepared share handoffs alive long enough for recipient apps to read
+ * them asynchronously (for example, an email composer attaching the file).
+ * Stale copies are collected before the next share; the OS may evict cache
+ * files sooner under storage pressure.
+ */
+const SHARE_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000
 const META_KEY_ROOT = "blobmeta_"
 /** Cap md5 computation so we don't block the JS thread hashing a huge file. */
 const MD5_MAX_BYTES = 50 * 1024 * 1024
@@ -662,6 +669,32 @@ export class BlobStore {
 
   // ---- share ---------------------------------------------------------------
 
+  /** Best-effort GC for prepared share handoffs retained in the OS cache. */
+  private cleanupShareCache(now = Date.now()): void {
+    try {
+      const root = new Directory(Paths.cache, SHARE_DIR_NAME)
+      if (!root.exists) return
+      const cutoff = now - SHARE_CACHE_MAX_AGE_MS
+      for (const entry of root.list()) {
+        if (!(entry instanceof Directory)) continue
+        try {
+          const info = entry.info()
+          // modificationTime is available on both platforms; creationTime can
+          // be absent on Android versions before API 26. The directory id
+          // begins with Date.now().toString(36), which is a final fallback.
+          const encoded = entry.name.split("-", 1)[0]
+          const encodedTime = /^[0-9a-z]+$/.test(encoded) ? Number.parseInt(encoded, 36) : Number.NaN
+          const timestamp = info.modificationTime ?? info.creationTime ?? encodedTime
+          if (Number.isFinite(timestamp) && timestamp < cutoff) entry.delete()
+        } catch {
+          // Keep scanning if one cache entry disappears or is unreadable.
+        }
+      }
+    } catch {
+      // Cache cleanup must never prevent a share.
+    }
+  }
+
   async handleShare(packageName: string, payload: Record<string, unknown>, requestId?: string): Promise<void> {
     const key = payload.key as string
     const meta = this.readMeta(packageName, key)
@@ -679,23 +712,33 @@ export class BlobStore {
     // applies to base64/data payloads, not file:// URLs), so sharing `file.uri`
     // directly would hand the recipient a machine-named file. Copy to a temp
     // file that carries the real display name + extension, share that, then
-    // clean it up.
+    // clean it up after the recipient has had time to consume it.
     const shareName = shareFileName(meta)
-    // Copy into a per-share unique subdir so two concurrent shares that resolve
-    // to the same display name can't clobber each other's temp file while
-    // Share.open still references it. The file keeps `shareName` as its basename
-    // so the OS share sheet shows the right name + extension.
+    // Key the cache directory by the immutable stored filename. Repeated or
+    // concurrent shares of the same blob can safely reference the same bytes,
+    // avoiding an extra full-sized cache copy for every share. Different blobs
+    // still get isolated directories even when they use the same display name.
+    // The file keeps `shareName` as its basename so the OS share sheet shows the
+    // right name + extension.
     let tempDir: Directory | null = null
+    let cacheReady = false
     try {
-      tempDir = new Directory(Paths.cache, SHARE_DIR_NAME, this.makeId())
-      tempDir.create({intermediates: true})
+      this.cleanupShareCache()
+      tempDir = new Directory(Paths.cache, SHARE_DIR_NAME, sanitizeSegment(meta.fileName))
+      if (!tempDir.exists) tempDir.create({intermediates: true})
       const temp = new File(tempDir, shareName)
-      file.copy(temp)
+      if (!temp.exists || temp.size !== meta.bytes) {
+        if (temp.exists) temp.delete()
+        file.copy(temp)
+      }
+      cacheReady = true
       await Share.open({
         url: temp.uri,
         type: meta.mimeType || OCTET,
         filename: shareName,
       })
+      // Share.open resolves once the OS accepts the handoff. Recipient apps may
+      // still read the URI asynchronously, so retain this cache copy for GC.
       this.hooks.sendResult(packageName, requestId, true, {success: true})
     } catch (error: any) {
       if (error?.message?.includes("User did not share")) {
@@ -705,7 +748,11 @@ export class BlobStore {
         this.hooks.sendResult(packageName, requestId, true, {success: false})
       }
     } finally {
-      if (tempDir) {
+      // Once a reusable cache entry is ready, retain it even if this particular
+      // sheet is cancelled or fails: another concurrent/recent share may still
+      // be reading the same file. Only remove an entry whose preparation did
+      // not finish; ready entries are collected after the retention window.
+      if (tempDir && !cacheReady) {
         try {
           if (tempDir.exists) tempDir.delete()
         } catch {

package/src/services/CustomDashboardModel.ts

@@ -0,0 +1,83 @@
+import type {ClientApp} from "../types/applet"
+import {DeviceTypes} from "../types/enums"
+
+/** Canonical widget order; also the default layout order. */
+export const DASHBOARD_WIDGET_IDS = ["clock", "calendar", "apps", "notifications"] as const
+export type DashboardWidgetId = (typeof DASHBOARD_WIDGET_IDS)[number]
+export type DashboardWidgetSetting = {id: DashboardWidgetId; enabled: boolean}
+
+export type DashboardAction = {kind: "apps-menu"} | {kind: "notifications"}
+export type AppMenuAction = {kind: "app"; packageName: string}
+
+export type MenuAppSetting = {packageName: string; name: string; running?: boolean}
+export type CustomDashboardClockStyle = "compact" | "large"
+
+/** G2.swift appends this marker after the firmware advertises EVENCFW capabilities. */
+export function isGlasslyCfwFirmwareVersion(firmwareVersion: string | null | undefined): boolean {
+  return firmwareVersion?.toLowerCase().includes("glassly cfw") === true
+}
+
+/** Stock G2 and NIMO are intentionally excluded. */
+export function isCustomDashboardEligible(info: {model?: string | null; firmwareVersion?: string | null}): boolean {
+  return info.model === DeviceTypes.G2 && isGlasslyCfwFirmwareVersion(info.firmwareVersion)
+}
+
+export function formatDashboardClock(
+  date: Date,
+  options: {twelveHour: boolean; showDate: boolean},
+): {time: string; date?: string} {
+  const time = new Intl.DateTimeFormat(undefined, {
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: options.twelveHour,
+  }).format(date)
+  if (!options.showDate) return {time}
+  return {
+    time,
+    date: new Intl.DateTimeFormat(undefined, {weekday: "short", month: "short", day: "numeric"}).format(date),
+  }
+}
+
+/**
+ * Saved widget order, sanitized: unknown/duplicate entries dropped, widgets
+ * missing from the saved value appended enabled in canonical order.
+ */
+export function normalizeDashboardWidgets(raw: unknown): DashboardWidgetSetting[] {
+  const widgets: DashboardWidgetSetting[] = []
+  if (Array.isArray(raw)) {
+    for (const entry of raw) {
+      if (!entry || typeof entry !== "object") continue
+      const id = (entry as {id?: unknown}).id as DashboardWidgetId
+      if (!DASHBOARD_WIDGET_IDS.includes(id)) continue
+      if (widgets.some((widget) => widget.id === id)) continue
+      widgets.push({id, enabled: (entry as {enabled?: unknown}).enabled !== false})
+    }
+  }
+  for (const id of DASHBOARD_WIDGET_IDS) {
+    if (!widgets.some((widget) => widget.id === id)) widgets.push({id, enabled: true})
+  }
+  return widgets
+}
+
+export function orderedDashboardApps(menu: MenuAppSetting[] | null | undefined, apps: ClientApp[]): ClientApp[] {
+  if (!Array.isArray(menu)) return []
+  return menu
+    .map((item) => apps.find((app) => app.packageName === item.packageName))
+    .filter((app): app is ClientApp => Boolean(app && !app.hidden && app.compatibility?.isCompatible !== false))
+}
+
+/** Focusable main-view actions, following the user's widget order. */
+export function dashboardActions(widgets: DashboardWidgetSetting[]): DashboardAction[] {
+  const actions: DashboardAction[] = []
+  for (const widget of widgets) {
+    if (!widget.enabled) continue
+    if (widget.id === "apps") actions.push({kind: "apps-menu"})
+    else if (widget.id === "notifications") actions.push({kind: "notifications"})
+  }
+  return actions
+}
+
+/** App-menu view rows: the Glasses Menu apps in order (double tap leaves the view). */
+export function appMenuActions(apps: ClientApp[]): AppMenuAction[] {
+  return apps.map((app): AppMenuAction => ({kind: "app", packageName: app.packageName}))
+}