@3dsource/angular-unreal-module 0.0.146-dev.0 → 0.0.146-dev.1

package/fesm2022/3dsource-angular-unreal-module.mjs

@@ -1,10 +1,10 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, DestroyRef, ChangeDetectionStrategy, Component, Injectable, signal, effect, untracked, computed, Pipe, input, ElementRef, viewChild, afterNextRender, HostListener, output, makeEnvironmentProviders, provideEnvironmentInitializer } from '@angular/core';
 import { SourceButtonComponent, SourceLoadingComponent } from '@3dsource/source-ui-native';
-import { Subject, skip, share, merge, map, scan, timestamp, startWith, pairwise, concatMap, of, animationFrameScheduler, interval, Observable, timer, take, defer, switchMap, from, throwError, EMPTY, retry, timeout as timeout$1, repeat, takeUntil as takeUntil$1, fromEvent, tap as tap$1, throttleTime, delay, concat, debounceTime, mergeMap, shareReplay, NEVER, asyncScheduler, filter as filter$1, withLatestFrom as withLatestFrom$1, Subscription, bufferTime, combineLatestWith, distinctUntilChanged as distinctUntilChanged$1 } from 'rxjs';
+import { Subject, skip, share, merge, map, scan, timestamp, startWith, pairwise, concatMap, of, animationFrameScheduler, interval, Observable, timer, take, defer, switchMap, from, throwError, EMPTY, retry, timeout as timeout$1, repeat, BehaviorSubject, takeUntil as takeUntil$1, fromEvent, tap as tap$1, throttleTime, delay, concat, debounceTime, mergeMap, ignoreElements, shareReplay, NEVER, asyncScheduler, filter as filter$1, withLatestFrom as withLatestFrom$1, Subscription, bufferTime, combineLatestWith, distinctUntilChanged as distinctUntilChanged$1 } from 'rxjs';
 import { createAction, props, createReducer, on, createFeature, Store, createSelector, provideState } from '@ngrx/store';
 import { whereNot, Falsy, Logger, calculateMedian, clampf, lerp, getCanvasCached, getSnapshot, fitIntoRectangle, generateUuid, Truthy, tapLog, Semaphore, COLOR_CODES, where, KeyboardNumericCode, InvertedKeyMap, HEXtoRGB, RGBtoHSV, inverseLerp, HSVtoRGB, RGBtoHEX, fpIsASameAsB } from '@3dsource/utils';
-import { filter, map as map$1, distinctUntilChanged, takeWhile, takeUntil, catchError, tap, timeout, finalize, first, switchMap as switchMap$1, withLatestFrom, exhaustMap, debounceTime as debounceTime$1, take as take$1, startWith as startWith$1 } from 'rxjs/operators';
+import { filter, map as map$1, distinctUntilChanged, takeWhile, takeUntil, catchError, tap, timeout, finalize, first, switchMap as switchMap$1, last, withLatestFrom, exhaustMap, debounceTime as debounceTime$1, take as take$1, startWith as startWith$1 } from 'rxjs/operators';
 import { Actions, ofType, createEffect, provideEffects } from '@ngrx/effects';
 import { concatLatestFrom } from '@ngrx/operators';
 import { DialogRef, DIALOG_DATA, Dialog } from '@angular/cdk/dialog';
@@ -643,10 +643,11 @@ const unrealReducer = createReducer(initialState, on(changeStatusMainVideoOnScen
     return { ...state, analyticsEvent: event };
 }), on(setCirrusConnected, (state) => {
     return { ...state, cirrusConnected: true };
-}), on(streamAdopted, (state, { machineId }) => {
+}), on(streamAdopted, (state, { machineId, ssData }) => {
     return {
         ...state,
         cirrusConnected: true,
+        ssData: ssData ?? state.ssData,
         awsInstance: {
             ...state.awsInstance,
             wsUrl: machineId,
@@ -1314,13 +1315,18 @@ const selectTotalProgress = createSelector(unrealFeature.selectStatusPercentSign
     const SIGNALLING_MAX = SIGNALLING_PERCENT_VALUE / 100;
     const ORCHESTRATION_WS_PATTERN = /^wss:\/\/orchestration-websocket/i;
     const isNewOrchestration = ORCHESTRATION_WS_PATTERN.test(awsInstance?.wsUrl ?? '');
-    // Orchestration progress is 0–1 from the backend; map to 0–1 directly.
-    // Once the data channel is connected, signaling is fully complete (1.0).
-    const signalingProgress = isNewOrchestration
-        ? dataChannelConnected
-            ? 1
-            : (awsInstance?.progressComplete ?? 0)
-        : (statusPercentSignallingServer ?? 0) / 100;
+    // Once the data channel is connected, signaling is fully complete (1.0) —
+    // regardless of orchestration type. This is what makes an ADOPTED stream
+    // (whose wsUrl is the machine host, not the orchestration-websocket URL,
+    // and which never set `statusPercentSignallingServer`) correctly show the
+    // whole first phase done instead of stalling near the command-only value.
+    // Otherwise: new orchestration reports 0–1 progress; legacy uses the
+    // polling percent.
+    const signalingProgress = dataChannelConnected
+        ? 1
+        : isNewOrchestration
+            ? (awsInstance?.progressComplete ?? 0)
+            : (statusPercentSignallingServer ?? 0) / 100;
     // +1% bump once WS URL is known (visual step for WS handshake)
     const splitPoint = awsInstance?.wsUrl
         ? SIGNALLING_MAX + 0.01
@@ -2573,7 +2579,13 @@ class VideoService extends SubService {
         this.audio = null;
         this.container = null;
         this.latencyTestTimings = new LatencyTimings();
-        this.videoTrack$ = new Subject();
+        // BehaviorSubject (not Subject) so a late subscriber to `videoStats$` still
+        // gets the current track. Adoption (`WebRtcPlayerService.adopt`) calls
+        // `attachVideoStream` synchronously/early — before the resize and app-init
+        // (`initAppByDataChannelReady$`) subscribers attach — and a plain Subject
+        // would drop that emission, so the stats interval (and `setViewportReady`,
+        // gated on `framesPerSecond`) would never start.
+        this.videoTrack$ = new BehaviorSubject(null);
         this.VideoEncoderQP = 0;
         this.aggregatedStats = {};
         this.kalmanFilter1D = new KalmanFilter1D(FilterModel.initialBitrateEstimate, FilterModel.initialErrorCovariance, FilterModel.processNoise, FilterModel.measurementNoise);
@@ -3566,6 +3578,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.2", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
 
+// How often to re-check `window.__stream.state` while a prefetch is connecting.
+const ADOPT_POLL_MS = 100;
 /**
  * Adopts a WebRTC connection prefetched by the `stream-prefetch.js` head-script
  * and parked on `window.__stream`, instead of running `connectToSignaling` from
@@ -3579,6 +3593,32 @@ class StreamAdoptionService {
         this.signalling = inject(SignallingService);
         this.webRtc = inject(WebRtcPlayerService);
     }
+    /**
+     * Decide adoption, WAITING for an in-flight prefetch instead of racing it.
+     *
+     * - nothing parked → emit `false` at once (caller connects normally).
+     * - already settled (`ready`/`failed`/`adopted`) → adopt-if-ready at once.
+     * - still `connecting` → poll until it settles, then adopt-if-ready. Bounded
+     *   by `timeoutMs` so a stuck prefetch can't block the fallback forever.
+     *
+     * Emits exactly once. Cancel by unsubscribing (the effect does this on
+     * teardown via `takeUntil`) — no adoption runs after cancellation, which is
+     * what stops a fast route-switch from starting overlapping connections.
+     */
+    awaitAndAdopt$(timeoutMs) {
+        const parked = window.__stream;
+        if (!parked) {
+            return of(false);
+        }
+        if (parked.state !== 'connecting') {
+            return of(this.tryAdopt());
+        }
+        Logger.info('[Adoption] Prefetch in progress — waiting before connecting');
+        return timer(0, ADOPT_POLL_MS).pipe(map$1(() => window.__stream?.state ?? 'failed'), 
+        // Keep polling while still connecting AND within budget; the `true`
+        // (inclusive) emits the settling value (or the last one at the deadline).
+        takeWhile((state, i) => state === 'connecting' && i * ADOPT_POLL_MS < timeoutMs, true), last(), map$1(() => this.tryAdopt()));
+    }
     /**
      * @returns `true` if a ready parked stream was adopted (caller must NOT
      *          start a fresh connection), `false` otherwise.
@@ -3601,11 +3641,15 @@ class StreamAdoptionService {
         // Stop the script's watchdog and mark the handoff complete.
         parked.adopt();
         // Flag cirrus connected (so a later `initSignalling` won't open a 2nd
-        // connection) and record the adopted machine. NOTE: clientId/viewId are
-        // left untouched — the host app (metabox) already set them authoritatively
-        // from its own data before `initSignalling`; the script's ids are only used
-        // internally to establish the prefetched connection.
-        this.store.dispatch(streamAdopted({ machineId: parked.machineId ?? null }));
+        // connection), record the adopted machine, and hydrate the streamer info
+        // (`ssData`) the prefetch captured from the `ssInfo` message. NOTE:
+        // clientId/viewId are left untouched — the host app (metabox) already set
+        // them authoritatively from its own data before `initSignalling`; the
+        // script's ids are only used internally to establish the connection.
+        this.store.dispatch(streamAdopted({
+            machineId: parked.machineId ?? null,
+            ssData: parked.ssData ?? null,
+        }));
         // Hand the live socket over without re-sending `requestStream`, reusing the
         // script's correlationId (the one `requestStream` was already sent with).
         this.signalling.adoptSocket(parked.ws, parked.ids.correlationId);
@@ -4148,12 +4192,21 @@ class UnrealEffects {
             }), map(([, matchMakerUrls]) => [...matchMakerUrls].filter(Truthy)), filter((urls) => urls.length > 0), 
             // Ensure a single in-flight request per attempt.
             exhaustMap((urls) => 
-            // Adopt a prefetched `window.__stream` if one is ready; otherwise
-            // fall back to opening a fresh signalling connection.
-            this.streamAdoptionService.tryAdopt()
-                ? EMPTY
-                : this.signallingService.connectToSignaling(urls)));
-        }, { dispatch: false });
+            // If a prefetched `window.__stream` is ready — or still connecting —
+            // adopt it (waiting for it to finish) instead of racing a second
+            // connection; otherwise fall back to a fresh signalling connection.
+            // `takeUntil(abort)` cancels the wait on teardown / route change so a
+            // fast switch can't leave overlapping connections.
+            this.streamAdoptionService
+                .awaitAndAdopt$(this.dataChannelConnectionTimeout)
+                .pipe(switchMap((adopted) => adopted ? EMPTY : this.signallingService.connectToSignaling(urls)), takeUntil(this.actions$.pipe(ofType(abortEstablishingConnection))), 
+            // The adopt/connect stream is side-effect-only (its values aren't
+            // actions) — swallow them, and emit `setEstablishingConnection`
+            // first so the reconnect/resume popup stays hidden during the
+            // (possibly deferred) prefetch-adoption wait. Adoption otherwise
+            // defers `connectToSignaling`, which is what normally sets this.
+            ignoreElements(), startWith(setEstablishingConnection({ value: true })))));
+        });
     }
     canPeerReconnect() {
         return RECONNECT_CONFIG.enabled && this.signallingService.isConnected();