@mentra/engine 3.2.0-dev.227 → 3.2.0-dev.233

package/src/services/LocalMiniappRuntime.ts

@@ -998,13 +998,14 @@ class LocalMiniappRuntime {
     // remain active for another subscriber; a rejected FOV release then stops
     // renewing the departed owner's lease and ASG restores it once idle.
     const cameraCleanup = Promise.allSettled([
+      this.leaveMeetingForApp(packageName),
       phonePhotoCoordinator.stopWarmUpForApp(packageName),
       phoneStreamCoordinator.stop(packageName),
       phoneVideoCoordinator.stopForApp(packageName),
     ]).then((results) => {
       for (const result of results) {
         if (result.status === "rejected") {
-          console.warn(`${LOG_TAG}: failed to stop camera consumer for ${packageName} on unregister`, result.reason)
+          console.warn(`${LOG_TAG}: failed to stop miniapp resource for ${packageName} on unregister`, result.reason)
         }
       }
     })
@@ -1038,10 +1039,6 @@ class LocalMiniappRuntime {
     // so a crashed/closed miniapp doesn't leak partial files or file handles.
     this.blobStore.onAppGone(packageName)
 
-    void acsMeetingService.leaveIfOwner(packageName).catch((error) => {
-      console.warn(`${LOG_TAG}: failed to leave ACS meeting for ${packageName} on unregister`, error)
-    })
-
     // Detach the per-app nav event forwarder but leave the native nav session
     // running. The user may have just closed the mini-app UI and will reopen
     // it; stopping the session here would kill an active trip mid-route.
@@ -3668,6 +3665,9 @@ class LocalMiniappRuntime {
 
   private ensureMeetingStateBridge(): void {
     acsMeetingService.setStateHandler((owner, state) => {
+      const attempt = this.softapAttempt
+      // While a replacement waits for cleanup, native events still describe its predecessor.
+      if (attempt?.packageName === owner && !attempt.ownsResources) return
       this.sendToMiniapp(owner, {
         type: MiniappResponseType.MEETING_STATE,
         ...state,
@@ -3675,6 +3675,16 @@ class LocalMiniappRuntime {
     })
   }
 
+  /** Startup owns the hotspot before ACS has an owner. Closing the app must retire both. */
+  private async leaveMeetingForApp(packageName: string): Promise<void> {
+    const attempt = this.softapAttempt
+    if (attempt?.packageName === packageName) {
+      await this.retireSoftapAttempt({attempt})
+    } else {
+      await acsMeetingService.leaveIfOwner(packageName)
+    }
+  }
+
   private async handleMeetingJoin(
     packageName: string,
     payload: Record<string, unknown>,
@@ -3903,7 +3913,8 @@ class LocalMiniappRuntime {
       return
     }
     attempt.progress = progress
-    const current = acsMeetingService.getState()
+    // A reservation waiting behind another call must not inherit that call's connected state.
+    const current = attempt.transport ? acsMeetingService.getState() : {state: "connecting", muted: false}
     this.sendToMiniapp(attempt.packageName, {
       type: MiniappResponseType.MEETING_STATE,
       ...current,
@@ -3937,6 +3948,7 @@ class LocalMiniappRuntime {
   ): Promise<MeetingState> {
     const packageName = attempt.packageName
     if (previous) {
+      this.narrateSoftapPreflight(attempt, "Finishing the previous call’s cleanup…")
       softapTrace("softap_join_superseding", {
         previousAttempt: previous.id,
         previousAgeMs: Date.now() - previous.startedAt,
@@ -4000,6 +4012,7 @@ class LocalMiniappRuntime {
           joinScopedNetwork: (ssid, passphrase, gateway) =>
             acsMeetingService.joinScopedNetwork(ssid, passphrase, gateway),
           leaveScopedNetwork: () => acsMeetingService.leaveScopedNetwork(),
+          cancelScopedNetworkJoin: () => acsMeetingService.cancelScopedNetworkJoin(),
           probeGateway: async () => {
             const verdict = await acsMeetingService.probeScopedGateway()
             // No native probe means no verdict, and the orchestrator must not read that as "down".
@@ -4251,7 +4264,7 @@ class LocalMiniappRuntime {
     // Teams configuration problem.
     const defaultNetworkStartedAt = Date.now()
     try {
-      const network = await acsMeetingService.awaitValidatedDefaultNetwork()
+      const network = await acsMeetingService.awaitDefaultNetworkAfterHotspot()
       softapTrace("softap_teardown_step", {
         attempt: attempt.id,
         step: "awaitValidatedDefaultNetwork",

package/src/services/SoftapCallTransport.ts

@@ -107,6 +107,8 @@ export interface SoftapCallDeps {
   /** Join the hotspot without taking the phone's default route. Resolves to the phone's own IPv4. */
   joinScopedNetwork(ssid: string, passphrase: string, report?: SoftapStepReporter): Promise<string | undefined>
   leaveScopedNetwork(): Promise<void>
+  /** Interrupt a pending native join while retaining its cleanup barrier. Unsupported hosts wait. */
+  cancelScopedNetworkJoin?(): Promise<void>
   /**
    * Join the meeting. This is what binds the local WHIP listener and arms the ACS raw outputs, so
    * it must resolve before the glasses are told to publish.
@@ -411,7 +413,7 @@ export class SoftapCallTransport {
           throw new Error("the meeting reported no ingest URL")
         }
         this.ingestUrl = ingestUrl
-        softapTrace("acs_joined", {ingestUrl})
+        softapTrace("acs_receiver_ready", {ingestUrl})
         report(`Receiver ready at ${ingestUrl}`)
       })
 
@@ -424,10 +426,10 @@ export class SoftapCallTransport {
       })
 
       await this.step(generation, "live", "NO_FIRST_FRAME", async (report) => {
-        report("Waiting for the first video frame to reach Teams")
+        report("Waiting for the first glasses video frame on this phone")
         await this.deps.awaitFirstFrame(report)
-        softapTrace("first_frame_in_acs")
-        report("Video is live in the meeting")
+        softapTrace("first_glasses_frame_received")
+        report("Glasses video is reaching this phone")
       })
 
       if (generation !== this.generation) {
@@ -500,9 +502,21 @@ export class SoftapCallTransport {
       // this call is still coming". Deliberately unbounded: a native call that never returns must
       // hold the next call back, never let it race this one's cleanup.
       if (running) {
+        const cancellation =
+          running.step === "scopedJoin" && this.deps.cancelScopedNetworkJoin
+            ? Promise.resolve()
+                .then(() => this.deps.cancelScopedNetworkJoin!())
+                .catch((error) => {
+                  if (!this.teardownFailures.includes("scopedJoin")) this.teardownFailures.push("scopedJoin")
+                  softapTraceFailure("softap_join_cancel_failed", {
+                    reason: error instanceof Error ? error.message : String(error),
+                  })
+                })
+            : undefined
         softapTrace("softap_stop_waiting_for_step", {step: running.step})
         const waitStartedAt = Date.now()
         await running.settled
+        await cancellation
         // This wait is unbounded by design, so its duration is the difference between "the leave
         // was slow" and "the leave was held by a native call that had not returned".
         softapTrace("softap_stop_step_settled", {step: running.step, waitedMs: Date.now() - waitStartedAt})
@@ -710,6 +724,7 @@ export function createSoftapCallDeps(args: {
     setHotspotState: (enabled: boolean) => Promise<{state: string; ssid?: string; password?: string; localIp?: string}>
     joinScopedNetwork: (ssid: string, passphrase: string, gateway?: string) => Promise<string | undefined>
     leaveScopedNetwork: () => Promise<void>
+    cancelScopedNetworkJoin?: () => Promise<void>
     joinMeeting: (
       packageName: string,
       options: {
@@ -853,6 +868,7 @@ export function createSoftapCallDeps(args: {
       return address
     },
     leaveScopedNetwork: () => subsystems.leaveScopedNetwork(),
+    cancelScopedNetworkJoin: subsystems.cancelScopedNetworkJoin,
     joinMeeting: async ({ssid, passphrase, bindAddress}, report) => {
       // The hotspot join just took this phone off Wi-Fi, so the route Teams needs is whatever
       // Android promoted in its place. Waiting for it to validate is what stopped the ACS join