@mentra/engine 3.2.0-dev.217 → 3.2.0-dev.222

package/build/services/SoftapCallTransport.d.ts

@@ -0,0 +1,365 @@
+/**
+ * @fileoverview Sequences a SoftAP call. Sequencing only — no sockets, no peers, no BLE.
+ *
+ * The glasses open a hotspot, the phone joins it without giving up its cellular route, and the
+ * glasses publish WebRTC straight to a listener on the phone. Cloudflare is not involved at all.
+ *
+ * The order below is the whole point of this file, and one step in it is load-bearing:
+ *
+ *   hotspot on -> scoped join -> ACS join (binds the listener and arms the raw outputs)
+ *     -> glasses publish -> WHIP negotiation -> first frame -> LIVE
+ *
+ * Publishing must come after the ACS join, not before. `LIVE` means a frame reached ACS, so if the
+ * glasses start publishing first, decoded video and audio can arrive before the raw outgoing
+ * streams exist and the first frames are dropped by whatever happens to be null at the time. That
+ * is not a lifecycle anyone designed; making the order explicit is what removes it.
+ *
+ * Ownership is deliberately narrow. This object owns the *sequence* and nothing else: the meeting
+ * session owns the WHIP listener and the peer, `PhoneStreamCoordinator` owns the publisher, and
+ * `localNetworkTransport` owns the scoped network. Every step therefore has exactly one owner that
+ * can tear it down, which is what makes leaving mid-join safe.
+ */
+/** Steps in order. Also the teardown order, reversed. */
+export declare const SOFTAP_STEPS: readonly ["hotspot", "scopedJoin", "acsJoin", "publish", "live"];
+export type SoftapStep = (typeof SOFTAP_STEPS)[number];
+/**
+ * Where the sequence is.
+ *
+ * `starting` covers every step up to `live` because the caller's only useful distinction is
+ * "not yet usable" versus "carrying media"; the step names are for diagnostics, not for branching.
+ */
+export type SoftapPhase = "idle" | "starting" | "live" | "stopping" | "failed";
+/** A failure, named by the step that produced it so the UI and the logs agree on the cause. */
+export declare class SoftapCallError extends Error {
+    readonly step: SoftapStep;
+    readonly code: string;
+    readonly cause?: unknown | undefined;
+    constructor(step: SoftapStep, code: string, message: string, cause?: unknown | undefined);
+}
+/** Gallery sync already learned this: glasses report enabled before the SSID is in the phone scan. */
+export declare const HOTSPOT_BROADCAST_WAIT_MS = 3000;
+export type SoftapStepStatus = "pending" | "running" | "done" | "failed";
+/**
+ * One step as the UI should show it. `detail` is the fact the step produced (SSID, phone address,
+ * ingest URL, what the glasses last reported); `error` is set only on `failed`.
+ */
+export interface SoftapStepState {
+    step: SoftapStep;
+    status: SoftapStepStatus;
+    detail?: string;
+    error?: string;
+    /** Wall-clock ms the step took; present once it is done or failed. */
+    durationMs?: number;
+}
+/**
+ * Whole-sequence snapshot, re-sent on every transition so a consumer that missed one still holds
+ * the truth. This is what the miniapp renders as its join checklist.
+ */
+export interface SoftapProgress {
+    traceId: string;
+    phase: SoftapPhase;
+    steps: SoftapStepState[];
+    /** ms since `start()` was called. */
+    elapsedMs: number;
+}
+/** Sub-status callback a step can use to narrate what it is doing while it runs. */
+export type SoftapStepReporter = (detail: string) => void;
+export interface SoftapCallDeps {
+    /** Enable the glasses hotspot and return its credentials. */
+    startHotspot(report?: SoftapStepReporter): Promise<{
+        ssid: string;
+        passphrase: string;
+    }>;
+    /**
+     * Wait until the phone can actually see the AP. `setHotspotState` resolves when the glasses
+     * accept the command, not when `ap0` is beaconing. A WifiNetworkSpecifier issued too early
+     * comes back `Unavailable` in well under a second — it does not keep scanning for the timeout.
+     */
+    waitUntilHotspotJoinable?(report?: SoftapStepReporter): Promise<void>;
+    /** Disable it. Must tolerate being called when it was never enabled. */
+    stopHotspot(): Promise<void>;
+    /** 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>;
+    /**
+     * 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.
+     *
+     * @returns the URL the glasses must POST their offer to
+     */
+    joinMeeting(args: {
+        ssid: string;
+        passphrase: string;
+        bindAddress?: string;
+    }, report?: SoftapStepReporter): Promise<{
+        ingestUrl: string;
+    }>;
+    leaveMeeting(): Promise<void>;
+    /**
+     * End the meeting for everyone instead of leaving it. Optional: a host that cannot do this still
+     * tears down correctly, it just cannot honour `stop({mode: "end"})`.
+     */
+    endMeeting?(): Promise<void>;
+    /** Tell the glasses to publish to [ingestUrl] in host-only ICE mode. */
+    startPublishing(args: {
+        ingestUrl: string;
+        traceId: string;
+    }, report?: SoftapStepReporter): Promise<void>;
+    stopPublishing(): Promise<void>;
+    /**
+     * Resolves when a frame has reached ACS, rejects if the feed failed or the deadline passed.
+     * Separate from [joinMeeting] because an answered negotiation is not a working call: a session
+     * that never delivers a frame reads as healthy behind a frozen tile.
+     */
+    awaitFirstFrame(report?: SoftapStepReporter): Promise<void>;
+}
+export interface SoftapCallOptions {
+    /** Override the minted trace id, so a caller can correlate with logs it already started. */
+    traceId?: string;
+    /**
+     * Receives a fresh snapshot on every transition: step begins, step narrates, step ends, sequence
+     * ends. Exceptions thrown here are swallowed — a broken listener must not fail the call.
+     */
+    onProgress?: (progress: SoftapProgress) => void;
+    /**
+     * Narration the caller already showed before the sequence existed — signing in to Teams, asking
+     * for a permission. Without it the first `emitProgress` would blank the checklist the wearer is
+     * already reading. Only `detail` is taken: the caller reports what it did, it does not get to
+     * claim a step ran.
+     */
+    initialSteps?: SoftapStepState[];
+}
+/**
+ * How a call is being taken down.
+ *
+ * `leave` takes this device out; `end` terminates the group call for everyone first. Everything
+ * after that step is identical, which is the point: End is not a second teardown path, it is one
+ * different verb at one step of the same one.
+ */
+export type SoftapTeardownMode = "leave" | "end";
+export interface SoftapStopOptions {
+    mode?: SoftapTeardownMode;
+    keepProgress?: boolean;
+}
+export declare class SoftapEndNotSupportedError extends Error {
+    constructor();
+}
+export declare class SoftapCallTransport {
+    private readonly deps;
+    private phase;
+    /**
+     * Steps completed and not yet undone, in the order they succeeded. Teardown walks this
+     * backwards, so a failure halfway through unwinds exactly what was built and nothing else.
+     */
+    private completed;
+    /**
+     * Bumped by every start and stop. A step that resolves after the caller has moved on must not
+     * write to the new attempt's state, which is the leave-during-join race.
+     */
+    private generation;
+    private stopping;
+    /**
+     * The step currently in flight, and a promise that settles only after its body *and* the undo it
+     * runs when it finds itself cancelled are both finished.
+     *
+     * This is what [stop] waits on. A step that resolves late still owns a resource — a hotspot that
+     * came up after the wearer left — and its release happens inside the step, out of the teardown's
+     * sight. Without this wait, `stop()` resolves while that release is still pending and the next
+     * call brings a hotspot up straight into it.
+     */
+    private running;
+    /** True once [start] has been called at least once, so [stop] can tell "cancelled" from "reusable". */
+    private startedEver;
+    /**
+     * A [stop] that landed before the sequence ever began.
+     *
+     * There is nothing to unwind in that case, so the flag is the only thing that can carry the
+     * cancellation forward: a `start()` arriving afterwards belongs to the attempt that was just
+     * cancelled and must refuse rather than build a call nobody is waiting for.
+     */
+    private cancelledBeforeStart;
+    /** Failed undos for this attempt, retained across repeated stops. See [lastTeardownFailures]. */
+    private teardownFailures;
+    /**
+     * Raised the instant a teardown is decided, before any resource is touched.
+     *
+     * Everything that watches the call for failure — a lost hotspot above all — has to be able to ask
+     * "was this supposed to happen?". Without the flag, releasing the scoped network during a
+     * successful Leave looks exactly like the glasses walking out of range, and the wearer gets an
+     * error screen for a call that ended the way they asked.
+     */
+    private terminating;
+    /** How this teardown ends the meeting. Read by the `acsJoin` undo. */
+    private teardownMode;
+    /** Set when `stop({mode: "end"})` could not end for everyone. The caller must not claim it did. */
+    private endFailure;
+    private hotspot;
+    private ingestUrl;
+    private steps;
+    private stepStartedAt;
+    private startedAt;
+    private traceId;
+    private onProgress;
+    constructor(deps: SoftapCallDeps);
+    currentPhase(): SoftapPhase;
+    /**
+     * True once a teardown has been decided. Anything that would otherwise report a failure — a lost
+     * hotspot, a dropped ACS call — must check this first: after the wearer asks to leave, those are
+     * the sound of it working.
+     */
+    isTerminating(): boolean;
+    /** What the UI should show right now. Safe to call in any phase. */
+    progress(): SoftapProgress;
+    private emitProgress;
+    private setStep;
+    /** Narration for a running step: what the phone or the glasses just reported. */
+    private note;
+    /** Steps currently built up, oldest first. Empty when nothing needs tearing down. */
+    activeSteps(): SoftapStep[];
+    /** The URL handed to the glasses, for diagnostics. Null outside a live attempt. */
+    currentIngestUrl(): string | null;
+    /**
+     * Steps whose undo threw during the last teardown, so the caller can refuse the next call.
+     *
+     * Teardown deliberately swallows these to keep unwinding — but a hotspot that would not turn off
+     * is exactly the state the next call cannot be built on, and starting anyway is what produced
+     * "Cannot start glasses hotspot" followed by a scoped join that never found the SSID.
+     */
+    lastTeardownFailures(): SoftapStep[];
+    /**
+     * Runs the sequence. On any failure the partial sequence is torn down before the error is
+     * rethrown, so a failed start never leaves a hotspot up or a publisher running.
+     */
+    start(options?: SoftapCallOptions): Promise<void>;
+    /**
+     * Tears down in exact reverse order, and only what was built.
+     *
+     * Every step is attempted even if an earlier one throws: a failure to stop the publisher must
+     * not leave the hotspot on. Concurrent calls share one teardown rather than racing each other
+     * through the same resources, and a second `stop()` after one finished is a no-op — this is the
+     * only SoftAP exit, so every terminal path can call it without checking whether another already
+     * did.
+     *
+     * `mode: "end"` swaps the meeting verb and nothing else. If ending for everyone fails, the rest of
+     * the teardown still runs and the failure is rethrown at the end, so the caller can tell the
+     * wearer they left a meeting that may still be live rather than inventing a clean end.
+     */
+    stop(options?: SoftapStopOptions): Promise<void>;
+    private undo;
+    /**
+     * The one step End changes.
+     *
+     * A failed End falls back to leaving, so the wearer is out either way, and the original failure is
+     * kept for [stop] to rethrow. Recording it rather than throwing here is what keeps the hotspot
+     * teardown — the steps after this one — unconditional.
+     */
+    private leaveOrEndMeeting;
+    /**
+     * Runs one step, records it as undoable, and maps any throw to a [SoftapCallError] naming the
+     * step. The generation check is what makes leaving mid-step safe: a step that resolves after the
+     * caller gave up is not recorded, so teardown does not try to undo it twice.
+     */
+    private step;
+    /** The step body itself. Split out so [step] can publish and settle {@link running} around it. */
+    private runStep;
+    /** Undo that reports rather than throws, for the cancellation path where there is no caller. */
+    private undoSafely;
+    private requireHotspot;
+    private requireIngestUrl;
+}
+/**
+ * Binds the sequence to the real subsystems.
+ *
+ * Kept separate from the class so the ordering above is tested against fakes rather than against
+ * BLE and ACS. The only logic here is adapting shapes; anything that needs a decision belongs in
+ * the class.
+ *
+ * @param packageName the miniapp that owns the call
+ * @param meeting the meeting to join, and how to observe its media health
+ */
+export declare function createSoftapCallDeps(args: {
+    packageName: string;
+    meetingUrl: string;
+    token: string;
+    displayName?: string;
+    /** Resolves when the meeting reports a frame reached ACS; rejects on a failed feed. */
+    awaitFirstFrame: () => Promise<void>;
+    subsystems: {
+        setHotspotState: (enabled: boolean) => Promise<{
+            state: string;
+            ssid?: string;
+            password?: string;
+        }>;
+        joinScopedNetwork: (ssid: string, passphrase: string) => Promise<string | undefined>;
+        leaveScopedNetwork: () => Promise<void>;
+        joinMeeting: (packageName: string, options: {
+            meetingUrl: string;
+            token: string;
+            videoSource: {
+                type: "softap";
+                ssid?: string;
+                passphrase?: string;
+                bindAddress?: string;
+            };
+            displayName?: string;
+        }) => Promise<unknown>;
+        leaveMeeting: (packageName: string) => Promise<void>;
+        /** Terminate the group call for everyone. Absent on hosts that cannot. */
+        endMeeting?: (packageName: string) => Promise<void>;
+        ingestUrl: () => string | null;
+        startPublishing: (packageName: string, options: {
+            streamUrl: string;
+            ice: {
+                stun: string;
+            };
+            traceId: string;
+            captureAudio?: boolean;
+        }) => Promise<unknown>;
+        stopPublishing: (packageName: string) => Promise<void>;
+        /**
+         * Whether the host is taking the wearer's voice off the glasses over BLE LC3 for this call.
+         *
+         * Asked after the meeting join and before the publish, because that is the only moment the
+         * answer is both known (the host has seen the native's capabilities) and still actionable (the
+         * glasses have not been told what to capture). True means the WHIP publish is video-only;
+         * false means the glasses put their microphone on the WHIP track as they always have. Absent
+         * on hosts that only have the WHIP audio path.
+         */
+        glassesLc3Uplink?: () => boolean;
+        /**
+         * Prove the phone can reach the glasses over the hotspot it just joined. Optional because
+         * only Android hosts have the scoped network handle; when present its verdict is narrated
+         * into the scoped-join step and a failure is reported, not thrown — the glasses-to-phone
+         * direction is what the call actually needs, and that is tested by the publish step.
+         */
+        probeGateway?: () => Promise<{
+            reachable: boolean;
+            detail: string;
+        }>;
+        /**
+         * Wait for the phone's default network to be validated again after the hotspot join took Wi-Fi
+         * away. Optional because only Android hosts can answer it.
+         *
+         * Not fatal when it reports an unusable network: the wearer is told, and the join is attempted
+         * anyway. Aborting here would fail calls that recover a second later, and the ACS join has its
+         * own bounded timeout for the case that does not.
+         */
+        awaitValidatedDefaultNetwork?: () => Promise<{
+            usable: boolean;
+            detail: string;
+        } | null>;
+        /**
+         * Glasses `stream_status` events, so the publish step can say "camera starting" and "offer
+         * posted" instead of going quiet for the whole BLE round trip. Returns an unsubscribe.
+         */
+        onGlassesStreamStatus?: (listener: (event: {
+            status: string;
+            streamId?: string;
+            reason?: string;
+            error?: string;
+        }) => void) => () => void;
+    };
+    /** Override only in tests. Production waits the gallery-proven broadcast window. */
+    hotspotBroadcastWaitMs?: number;
+}): SoftapCallDeps;
+//# sourceMappingURL=SoftapCallTransport.d.ts.map

package/build/services/SoftapCallTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoftapCallTransport.d.ts","sourceRoot":"","sources":["../../src/services/SoftapCallTransport.ts"],"names":[],"mappings":"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"}