@glassly/engine 0.3.7 → 0.3.8-dev.976

package/build/services/LocalMiniappRuntime.js

@@ -132,6 +132,17 @@ function withTimeout(promise, timeoutMs) {
         promise.then((value) => done(value), () => done(null));
     });
 }
+/** Bounds the cold-GPS wait for a one-shot poll; on a stall, any older fix beats an error. */
+const FRESH_LOCATION_TIMEOUT_MS = 8_000;
+async function freshLocationOrStale() {
+    const fresh = await withTimeout(Location.getCurrentPositionAsync({ accuracy: Location.Accuracy.Low }), FRESH_LOCATION_TIMEOUT_MS);
+    if (fresh)
+        return fresh;
+    const stale = await Location.getLastKnownPositionAsync();
+    if (stale)
+        return stale;
+    throw new Error("No location fix available");
+}
 const LOG_TAG = "LOCAL_MINIAPP";
 const DIAGNOSTIC_MAX_LIST_ITEMS = 100;
 const DIAGNOSTIC_MAX_STRING_LENGTH = 512;
@@ -152,6 +163,8 @@ const SYSTEM_MINIAPP_PACKAGES = new Set([
     "com.glassly.miniappdev",
 ]);
 const PING_INTERVAL_MS = 5_000;
+/** How long a stopping miniapp's `beforeDisconnect` handlers get before teardown. */
+const WILL_DISCONNECT_GRACE_MS = 100;
 // Min gap between "transcription limit reached" notices on the glasses. A
 // debounce, not a cooldown: the cloud re-announces the block per refused
 // subscribe, and miniapps retry in bursts — this only coalesces those bursts
@@ -981,20 +994,26 @@ class LocalMiniappRuntime {
      * undeliverable anyway.
      */
     async gracefullyUnregisterApp(packageName, reason = "unregistering") {
-        const app = this.connectedApps.get(packageName);
-        if (!app)
+        if (!this.connectedApps.has(packageName))
             return;
-        console.log(`${LOG_TAG}: gracefullyUnregisterApp(${packageName}) — sending WILL_DISCONNECT`);
-        this.sendToMiniapp(packageName, {
-            type: MiniappResponseType.WILL_DISCONNECT,
-            reason,
-        });
-        // 50 ms: imperceptible to the user, plenty of time for the SDK's
-        // synchronous `beforeDisconnect` handlers to flush a final
-        // sendOneShot through the still-open transport.
-        await new Promise((resolve) => BgTimer.setTimeout(resolve, 50));
+        await this.notifyWillDisconnect(packageName, reason);
         this.unregisterApp(packageName);
     }
+    /**
+     * Send `WILL_DISCONNECT` and wait out the grace window, so the session's
+     * `beforeDisconnect` handlers run (Navigation clears its HUD and ends its
+     * trip) and their last messages land before teardown. No-op unless the
+     * app finished its handshake.
+     */
+    async notifyWillDisconnect(packageName, reason) {
+        if (!this.connectedApps.has(packageName) || !this.handshookApps.has(packageName))
+            return;
+        console.log(`${LOG_TAG}: ${packageName} — sending WILL_DISCONNECT (${reason})`);
+        this.sendToMiniapp(packageName, { type: MiniappResponseType.WILL_DISCONNECT, reason });
+        // The message and the replies it triggers each cross a JSContext hop;
+        // short enough not to slow an app switch noticeably.
+        await new Promise((resolve) => BgTimer.setTimeout(resolve, WILL_DISCONNECT_GRACE_MS));
+    }
     unregisterApp(packageName, opts) {
         console.log(`${LOG_TAG}: unregisterApp(${packageName})`);
         const releasedMicGateOverride = micStateCoordinator.clearMiniappGateOverrides(packageName);
@@ -2966,7 +2985,7 @@ class LocalMiniappRuntime {
             const locationStartedAt = Date.now();
             const cached = await Location.getLastKnownPositionAsync({ maxAge: 60_000 });
             console.log(`${LOG_TAG}: location poll cache hit=${cached !== null} elapsed=${Date.now() - locationStartedAt}ms`);
-            const location = cached ?? (await Location.getCurrentPositionAsync({ accuracy: Location.Accuracy.Low }));
+            const location = cached ?? (await freshLocationOrStale());
             console.log(`${LOG_TAG}: location poll resolved elapsed=${Date.now() - locationStartedAt}ms`);
             this.sendResult(packageName, requestId, true, {
                 lat: location.coords.latitude,
@@ -5294,14 +5313,18 @@ class LocalMiniappRuntime {
         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;
-        }
-        return useAppStatusStore.getState().start(app, { skipNavigation: true });
+        // session.miniapps.start comes from the glasses (the dashboard's Apps menu,
+        // an Assist voice command), unlike a headless action wake, which carries no source.
+        // The full start, as a phone open runs it: the standard peer stops so this
+        // app owns the display, and an app already running hears the new launch.
+        const launchSource = "glasses";
+        const started = await useAppStatusStore.getState().start(app, { skipNavigation: true, launchSource });
+        if (!started)
+            return false;
+        // The caller may message the app next; start() resolves at spawn.
+        if (app.local)
+            await miniappLauncher.ensureConnected(packageName, undefined, { launchSource });
+        return true;
     }
     stopInteropApp(packageName) {
         return useAppStatusStore.getState().stop(packageName);
@@ -5979,6 +6002,17 @@ class LocalMiniappRuntime {
         }
         this.sendToMiniapp(packageName, { type: MiniappResponseType.LINK, params });
     }
+    /**
+     * Tell a running miniapp the user opened it again and from where. The
+     * CONNECT_ACK only carries the source of the spawn, which is stale for a
+     * background app that keeps running between opens.
+     */
+    sendLaunchChange(packageName, launchSource) {
+        const existing = this.connectedApps.get(packageName);
+        if (existing)
+            existing.launchSource = launchSource;
+        this.sendToMiniapp(packageName, { type: MiniappResponseType.LAUNCH_CHANGE, launchSource });
+    }
     /**
      * Send a VISIBILITY_CHANGE push to a miniapp.
      */