@100mslive/hms-video-store 0.15.1-alpha.1 → 0.15.1-alpha.2

package/dist/analytics/AnalyticsEventFactory.d.ts

@@ -40,6 +40,23 @@ export default class AnalyticsEventFactory {
     }): AnalyticsEvent;
     static hlsPlayerError(error: HMSException): AnalyticsEvent;
     static subscribeFail(error: Error): AnalyticsEvent;
+    /**
+     * An attempt went unanswered and is being retried. `sent` separates bytes the SFU ignored from
+     * an attempt that never reached the wire; `unproven` marks the channel-open race among the former.
+     */
+    static subscribeRequestRetry(properties: {
+        method: string;
+        trackId: string;
+        attempt: number;
+        unproven: boolean;
+        sent: boolean;
+    }): AnalyticsEvent;
+    /** no attempt was answered, so the SFU is left on a state nobody asked for */
+    static subscribeRequestUnanswered(properties: {
+        method: string;
+        trackId: string;
+        attempts: number;
+    }): AnalyticsEvent;
     static leave(): AnalyticsEvent;
     static autoplayError(): AnalyticsEvent;
     static audioPlaybackError(error: HMSException): AnalyticsEvent;

package/dist/connection/channel-messages.d.ts

@@ -13,6 +13,11 @@ export interface PreferLayerResponse {
         code: number;
         message: string;
     };
+    /**
+     * Resolved locally without the SFU ever answering - the request was superseded, or skipped. The
+     * caller must not read it as the SFU having applied the state.
+     */
+    dropped?: boolean;
 }
 export interface PreferAudioLayerParams {
     params: {

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

@@ -1,10 +1,12 @@
 import ISubscribeConnectionObserver from './ISubscribeConnectionObserver';
+import { EventBus } from '../../events/EventBus';
 import { InitFlags } from '../../signal/init/models';
 import JsonRpcSignal from '../../signal/jsonrpc';
 import { PreferAudioLayerParams, PreferLayerResponse, PreferVideoLayerParams } from '../channel-messages';
 import HMSConnection from '../HMSConnection';
 export default class HMSSubscribeConnection extends HMSConnection {
     private isFlagEnabled;
+    private eventBus?;
     private readonly TAG;
     private readonly remoteStreams;
     protected readonly observer: ISubscribeConnectionObserver;
@@ -17,6 +19,18 @@ export default class HMSSubscribeConnection extends HMSConnection {
      * apply stale desired state over a newer request.
      */
     private readonly RESPONSE_TIMEOUT;
+    /**
+     * The SFU creates this channel, so by DCEP the client's `open` fires a half-RTT before the SFU's
+     * and a request sent in that window is dropped before it arrives. Replies measure single-digit
+     * ms, so a request with no answer by now was lost rather than slow - and every ms spent waiting
+     * is a black tile. Applies only until the SFU has answered once; see `channelProven`.
+     */
+    private readonly UNPROVEN_CHANNEL_TIMEOUT;
+    /**
+     * Any reply proves the SFU's end of the channel is up, so the open race is behind us and a slow
+     * reply is the SFU being slow. Reset per channel: an SFU migration binds a new one.
+     */
+    private channelProven;
     readonly nativeConnection: RTCPeerConnection;
     private pendingMessageQueue;
     /** `${method}:${track_id}` -> the id of the newest request for it; older ones stop retrying */
@@ -32,14 +46,21 @@ export default class HMSSubscribeConnection extends HMSConnection {
     private apiChannel?;
     private eventEmitter;
     private initNativeConnectionCallbacks;
-    constructor(signal: JsonRpcSignal, config: RTCConfiguration, isFlagEnabled: (flag: InitFlags) => boolean, observer: ISubscribeConnectionObserver);
+    constructor(signal: JsonRpcSignal, config: RTCConfiguration, isFlagEnabled: (flag: InitFlags) => boolean, observer: ISubscribeConnectionObserver, eventBus?: EventBus | undefined);
+    /**
+     * Drops the claim on one piece of subscription state, so anything still chasing it stops and
+     * resolves as dropped. The SFU telling us where it is overrules a request for somewhere else:
+     * without this the retries replay the overruled bytes and leave the SFU holding a preference
+     * the client has moved off, which the allocator restores to on the next bandwidth recovery.
+     */
+    cancelPendingRequest(method: string, trackId: string): void;
     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>;
+    sendOverApiDataChannelWithResponse<T extends PreferAudioLayerParams | PreferVideoLayerParams>(message: T): Promise<PreferLayerResponse>;
     close(): void;
     /**
      * Settles `wait` early if the connection is closed while it is parked on the api data channel.
@@ -49,11 +70,19 @@ export default class HMSSubscribeConnection extends HMSConnection {
     private abortOnClose;
     private handlePendingApiMessages;
     private sendMessage;
+    /** stateKey is `${method}:${track_id}`; the track id is the half that identifies the stuck track */
+    private publishRequestEvent;
     /**
      * 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;
+    /**
+     * Only the first send on an unproven channel gets the short bound. A request dropped in the open
+     * window is answered by resending at once, but a link slow enough to miss 500ms twice is slow
+     * rather than dropping, and hard-failing it would strand the high-RTT clients the 10s bound
+     * exists for.
+     */
     private waitForResponse;
 }

package/dist/error/ErrorFactory.d.ts

@@ -68,7 +68,6 @@ export declare const ErrorFactory: {
         ProcessingFailed(action: HMSAction, description?: string): HMSException;
         AddAlreadyInProgress(action: HMSAction, description?: string): HMSException;
         DeviceNotSupported(action: HMSAction, description?: string): HMSException;
-        NotAllowedForRoom(action: HMSAction, description?: string): HMSException;
     };
     PlaylistErrors: {
         NoEntryToPlay(action: HMSAction, description: string): HMSException;