@100mslive/hms-video-store 0.14.8-alpha.0 → 0.14.8-alpha.2

package/dist/connection/subscribe/subscribeConnection.d.ts

@@ -10,20 +10,50 @@ export default class HMSSubscribeConnection extends HMSConnection {
     protected readonly observer: ISubscribeConnectionObserver;
     private readonly MAX_RETRIES;
     /**
-     * The SFU answers within a few ms, but a request sent right as the data channel opens has been
-     * seen to go unanswered. Without a bound here that caller waits for the rest of the session.
+     * Bounds both waits on the api data channel - for it to open, and for a reply. The first request
+     * of a session has been seen to go unanswered, and a channel that is closed or replaced never
+     * emits 'open' again; unbounded, either leaves that caller waiting for the rest of the session.
+     * Deliberately generous: a retry replays the original serialized request, so a premature one can
+     * apply stale desired state over a newer request.
      */
     private readonly RESPONSE_TIMEOUT;
     readonly nativeConnection: RTCPeerConnection;
     private pendingMessageQueue;
+    /** `${method}:${track_id}` -> the id of the newest request for it; older ones stop retrying */
+    private latestRequestPerState;
+    private closed;
+    /**
+     * Rejectors for the waits currently parked on the api data channel. close() fires them so a
+     * leave or an SFU migration settles every pending request at once, rather than each waiting out
+     * its RESPONSE_TIMEOUT first - the catch below breaks on `closed`, so it is one timeout per
+     * track, but that is still 10s of nothing per tile on every leave.
+     */
+    private pendingAborts;
     private apiChannel?;
     private eventEmitter;
     private initNativeConnectionCallbacks;
     constructor(signal: JsonRpcSignal, config: RTCConfiguration, isFlagEnabled: (flag: InitFlags) => boolean, observer: ISubscribeConnectionObserver);
     sendOverApiDataChannel(message: string): void;
+    /**
+     * A retry replays the bytes serialised here, so a request still retrying after a newer one has
+     * been made for the same track would re-apply state the caller has moved on from. Each request
+     * claims its piece of subscription state, and stops once it no longer holds the claim.
+     */
     sendOverApiDataChannelWithResponse<T extends PreferAudioLayerParams | PreferVideoLayerParams>(message: T, requestId?: string): Promise<PreferLayerResponse>;
     close(): void;
+    /**
+     * Settles `wait` early if the connection is closed while it is parked on the api data channel.
+     * The wait is cancelled rather than just abandoned: eventemitter2 keeps the listener subscribed
+     * until its own timeout otherwise, and the emitter is capped at 60.
+     */
+    private abortOnClose;
     private handlePendingApiMessages;
     private sendMessage;
+    /**
+     * Checked per attempt rather than once up front: 'open' is emitted from the channel's onopen, so
+     * a channel that is closed or replaced never emits again and an unbounded wait here would hang
+     * the caller for the rest of the session.
+     */
+    private waitForChannelOpen;
     private waitForResponse;
 }

package/dist/device-manager/AudioOutputManager.d.ts

@@ -4,14 +4,14 @@ export interface IAudioOutputManager {
     getDevice(): MediaDeviceInfo | undefined;
     setDevice(deviceId: string): Promise<MediaDeviceInfo | undefined>;
     getVolume(): number;
-    setVolume(value: number): void;
+    setVolume(value: number): Promise<void>;
 }
 export declare class AudioOutputManager implements IAudioOutputManager {
     private deviceManager;
     private audioSinkManager;
     constructor(deviceManager: DeviceManager, audioSinkManager: AudioSinkManager);
     getVolume(): number;
-    setVolume(value: number): void;
+    setVolume(value: number): Promise<void>;
     getDevice(): MediaDeviceInfo | undefined;
     setDevice(deviceId?: string): Promise<MediaDeviceInfo | undefined>;
     unblockAutoplay(): Promise<void>;