@100mslive/hms-video-store 0.10.29-alpha.1 → 0.11.0

package/dist/connection/HMSDataChannel.d.ts

@@ -0,0 +1,15 @@
+export interface DataChannelObserver {
+    onMessage(value: string): void;
+}
+export default class HMSDataChannel {
+    private readonly TAG;
+    private readonly nativeChannel;
+    private readonly observer;
+    private readonly metadata;
+    get id(): number | null;
+    get label(): string;
+    get readyState(): RTCDataChannelState;
+    constructor(nativeChannel: RTCDataChannel, observer: DataChannelObserver, metadata?: string);
+    send(message: string): void;
+    close(): void;
+}

package/dist/connection/IConnectionObserver.d.ts

@@ -0,0 +1,4 @@
+export default interface IConnectionObserver {
+    onIceConnectionChange(newState: RTCIceConnectionState): void;
+    onConnectionStateChange(newState: RTCPeerConnectionState): void;
+}

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

@@ -0,0 +1,30 @@
+import { HMSSimulcastLayer } from '../interfaces';
+import { HMSPreferredSimulcastLayer } from '../interfaces/simulcast-layers';
+export interface PreferVideoLayerParams {
+    params: {
+        max_spatial_layer: HMSSimulcastLayer;
+        track_id: string;
+    };
+    method: 'prefer-video-track-state';
+}
+export interface PreferLayerResponse {
+    id: string;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+export interface PreferAudioLayerParams {
+    params: {
+        subscribed: boolean;
+        track_id: string;
+    };
+    method: 'prefer-audio-track-state';
+}
+export interface VideoTrackLayerUpdate {
+    current_layer: HMSSimulcastLayer;
+    expected_layer: HMSPreferredSimulcastLayer;
+    track_id: string;
+    subscriber_degraded: boolean;
+    publisher_degraded: boolean;
+}

package/dist/connection/model.d.ts

@@ -0,0 +1,8 @@
+export declare enum HMSConnectionRole {
+    Publish = 0,
+    Subscribe = 1
+}
+export interface HMSTrickle {
+    candidate: RTCIceCandidateInit;
+    target: HMSConnectionRole;
+}

package/dist/connection/publish/IPublishConnectionObserver.d.ts

@@ -0,0 +1,10 @@
+import IConnectionObserver from '../IConnectionObserver';
+export interface IPublishConnectionObserver extends IConnectionObserver {
+    /** Triggered when renegotiation is necessary.
+     * - A new local track/stream is added/removed
+     * - A new data-channel is added/removed
+     */
+    onRenegotiationNeeded(): Promise<void>;
+    onDTLSTransportStateChange: (state?: RTCDtlsTransportState) => void;
+    onDTLSTransportError: (error: Error) => void;
+}

package/dist/connection/publish/publishConnection.d.ts

@@ -0,0 +1,11 @@
+import { IPublishConnectionObserver } from './IPublishConnectionObserver';
+import JsonRpcSignal from '../../signal/jsonrpc';
+import HMSConnection from '../HMSConnection';
+export default class HMSPublishConnection extends HMSConnection {
+    private readonly TAG;
+    private readonly observer;
+    readonly nativeConnection: RTCPeerConnection;
+    readonly channel: RTCDataChannel;
+    constructor(signal: JsonRpcSignal, config: RTCConfiguration, observer: IPublishConnectionObserver);
+    initAfterJoin(): void;
+}

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

@@ -0,0 +1,14 @@
+import { HMSTrack } from '../../media/tracks/HMSTrack';
+import IConnectionObserver from '../IConnectionObserver';
+export default interface ISubscribeConnectionObserver extends IConnectionObserver {
+    /** Triggered when a remote peer opens a DataChannel.
+     * Internally there is a data channel with label [API_DATA_CHANNEL]
+     * which is internally.
+     *
+     * TODO: Notify about all the other data channels to the sdk-layer */
+    onApiChannelMessage(message: string): void;
+    /** Triggered when media is received on a new streams from remote peer. */
+    onTrackAdd(track: HMSTrack): void;
+    /** Triggered when a remote peer close a streams.*/
+    onTrackRemove(track: HMSTrack): void;
+}

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

@@ -0,0 +1,24 @@
+import ISubscribeConnectionObserver from './ISubscribeConnectionObserver';
+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 readonly TAG;
+    private readonly remoteStreams;
+    private readonly observer;
+    private readonly MAX_RETRIES;
+    readonly nativeConnection: RTCPeerConnection;
+    private pendingMessageQueue;
+    private apiChannel?;
+    private eventEmitter;
+    private initNativeConnectionCallbacks;
+    constructor(signal: JsonRpcSignal, config: RTCConfiguration, isFlagEnabled: (flag: InitFlags) => boolean, observer: ISubscribeConnectionObserver);
+    sendOverApiDataChannel(message: string): void;
+    sendOverApiDataChannelWithResponse<T extends PreferAudioLayerParams | PreferVideoLayerParams>(message: T, requestId?: string): Promise<PreferLayerResponse>;
+    close(): Promise<void>;
+    private handlePendingApiMessages;
+    private sendMessage;
+    private waitForResponse;
+}

package/dist/controller/beam/BeamSpeakerLabelsLogger.d.ts

@@ -1,5 +1,5 @@
-import { HMSGenericTypes, HMSPeer, IHMSStore } from '../../core';
-import { IHMSActions } from '../../core/IHMSActions';
+import { HMSGenericTypes, HMSPeer, IHMSStore } from '../../';
+import { IHMSActions } from '../../IHMSActions';
 /**
  * Log data of audio level and speaker speaking periodically to beam for transcript
  * diarization.

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

@@ -0,0 +1,18 @@
+import { DeviceManager } from './DeviceManager';
+import { AudioSinkManager } from '../audio-sink-manager';
+export interface IAudioOutputManager {
+    getDevice(): MediaDeviceInfo | undefined;
+    setDevice(deviceId: string): Promise<MediaDeviceInfo | undefined>;
+    getVolume(): number;
+    setVolume(value: number): void;
+}
+export declare class AudioOutputManager implements IAudioOutputManager {
+    private deviceManager;
+    private audioSinkManager;
+    constructor(deviceManager: DeviceManager, audioSinkManager: AudioSinkManager);
+    getVolume(): number;
+    setVolume(value: number): void;
+    getDevice(): MediaDeviceInfo | undefined;
+    setDevice(deviceId?: string): Promise<MediaDeviceInfo | undefined>;
+    unblockAutoplay(): Promise<void>;
+}

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

@@ -0,0 +1,57 @@
+import { EventBus } from '../events/EventBus';
+import { DeviceMap, SelectedDevices } from '../interfaces';
+import { Store } from '../sdk/store';
+interface HMSDeviceManager extends DeviceMap {
+    outputDevice?: MediaDeviceInfo;
+    hasWebcamPermission: boolean;
+    hasMicrophonePermission: boolean;
+}
+export declare class DeviceManager implements HMSDeviceManager {
+    private store;
+    private eventBus;
+    audioInput: MediaDeviceInfo[];
+    audioOutput: MediaDeviceInfo[];
+    videoInput: MediaDeviceInfo[];
+    outputDevice?: MediaDeviceInfo;
+    hasWebcamPermission: boolean;
+    hasMicrophonePermission: boolean;
+    private readonly TAG;
+    private initialized;
+    private videoInputChanged;
+    private audioInputChanged;
+    constructor(store: Store, eventBus: EventBus);
+    updateOutputDevice: (deviceId?: string) => Promise<MediaDeviceInfo | undefined>;
+    init(force?: boolean): Promise<void>;
+    getDevices(): DeviceMap;
+    cleanup(): void;
+    getCurrentSelection: () => SelectedDevices;
+    private createIdentifier;
+    private computeChange;
+    private enumerateDevices;
+    private handleDeviceChange;
+    /**
+     * Function to get the device after device change
+     * Chrome and Edge provide a default device from which we select the actual device
+     * Firefox and safari give 0th device as system default
+     * @returns {MediaDeviceInfo}
+     */
+    getNewAudioInputDevice(): MediaDeviceInfo | undefined;
+    /**
+     * This method is to select the input/output from same group
+     * same group meaning both input/output are of same device
+     * This method might override the default coming from browser and system so as to select options from same
+     * device type. This is required in certain cases where browser's default is not correct.
+     * Algo:
+     * 1. find the non default input device if selected one is default by matching device label
+     * 2. find the corresponding output device which has the same group id or same label
+     * 3. select the previous selected device if nothing was found
+     * 4. select the default one if no matching device was found and previous device doesn't exist anymore
+     * 5. select the first option if there is no default
+     */
+    setOutputDevice(deviceChange?: boolean): Promise<void>;
+    private handleAudioInputDeviceChange;
+    private handleVideoInputDeviceChange;
+    private getAudioOutputDeviceMatchingInput;
+    private logDevices;
+}
+export {};

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

@@ -0,0 +1,30 @@
+import { DeviceMap, SelectedDevices } from '../interfaces';
+declare type DeviceInfo = {
+    deviceId?: string;
+    groupId?: string;
+};
+/**
+ * This class is to manage storing and retrieving selected devices
+ * from localstorage
+ * @internal
+ */
+declare class DeviceStorage {
+    private storage;
+    private remember;
+    private devices?;
+    private readonly TAG;
+    setDevices(devices: DeviceMap): void;
+    rememberDevices(value: boolean): void;
+    /**
+     * This will update the passed in type value in storage
+     * @param {string} type - One of audioInput | videoInput | audioOutput
+     * @param {DeviceInfo} param
+     * @returns {void}
+     */
+    updateSelection(type: 'audioInput' | 'videoInput' | 'audioOutput', { deviceId, groupId }: DeviceInfo): void;
+    getSelection(): SelectedDevices | undefined;
+    cleanup(): void;
+    private isSame;
+}
+export declare const DeviceStorageManager: DeviceStorage;
+export {};

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

@@ -0,0 +1,15 @@
+export declare const DevicesWiredHeadphonesWithoutMic: {
+    audioInput: MediaDeviceInfo[];
+    audioOutput: MediaDeviceInfo[];
+    videoInput: MediaDeviceInfo[];
+};
+export declare const DevicesWiredHeadphonesWithMic: {
+    audioInput: MediaDeviceInfo[];
+    audioOutput: MediaDeviceInfo[];
+    videoInput: MediaDeviceInfo[];
+};
+export declare const DevicesWithStereoHeadphones: {
+    audioInput: MediaDeviceInfo[];
+    audioOutput: MediaDeviceInfo[];
+    videoInput: MediaDeviceInfo[];
+};

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

@@ -0,0 +1 @@
+export { DeviceManager } from './DeviceManager';

package/dist/error/ErrorCodes.d.ts

@@ -0,0 +1,64 @@
+export declare const ErrorCodes: {
+    WebSocketConnectionErrors: {
+        FAILED_TO_CONNECT: number;
+        WEBSOCKET_CONNECTION_LOST: number;
+        ABNORMAL_CLOSE: number;
+    };
+    APIErrors: {
+        SERVER_ERRORS: number;
+        INIT_CONFIG_NOT_AVAILABLE: number;
+        ENDPOINT_UNREACHABLE: number;
+        INVALID_TOKEN_FORMAT: number;
+    };
+    TracksErrors: {
+        GENERIC_TRACK: number;
+        CANT_ACCESS_CAPTURE_DEVICE: number;
+        DEVICE_NOT_AVAILABLE: number;
+        DEVICE_IN_USE: number;
+        DEVICE_LOST_MIDWAY: number;
+        NOTHING_TO_RETURN: number;
+        INVALID_VIDEO_SETTINGS: number;
+        CODEC_CHANGE_NOT_PERMITTED: number;
+        AUTOPLAY_ERROR: number;
+        OVER_CONSTRAINED: number;
+        NO_AUDIO_DETECTED: number;
+        SYSTEM_DENIED_PERMISSION: number;
+        CURRENT_TAB_NOT_SHARED: number;
+        AUDIO_PLAYBACK_ERROR: number;
+        SELECTED_DEVICE_MISSING: number;
+    };
+    WebrtcErrors: {
+        CREATE_OFFER_FAILED: number;
+        CREATE_ANSWER_FAILED: number;
+        SET_LOCAL_DESCRIPTION_FAILED: number;
+        SET_REMOTE_DESCRIPTION_FAILED: number;
+        ICE_FAILURE: number;
+        ICE_DISCONNECTED: number;
+        STATS_FAILED: number;
+    };
+    WebsocketMethodErrors: {
+        SERVER_ERRORS: number;
+        ALREADY_JOINED: number;
+        CANNOT_JOIN_PREVIEW_IN_PROGRESS: number;
+    };
+    GenericErrors: {
+        NOT_CONNECTED: number;
+        SIGNALLING: number;
+        UNKNOWN: number;
+        NOT_READY: number;
+        JSON_PARSING_FAILED: number;
+        TRACK_METADATA_MISSING: number;
+        RTC_TRACK_MISSING: number;
+        PEER_METADATA_MISSING: number;
+        INVALID_ROLE: number;
+        PREVIEW_IN_PROGRESS: number;
+        MISSING_MEDIADEVICES: number;
+        MISSING_RTCPEERCONNECTION: number;
+        LOCAL_STORAGE_ACCESS_DENIED: number;
+        VALIDATION_FAILED: number;
+    };
+    PlaylistErrors: {
+        NO_ENTRY_TO_PLAY: number;
+        NO_ENTRY_IS_PLAYING: number;
+    };
+};

package/dist/error/ErrorFactory.d.ts

@@ -0,0 +1,74 @@
+import { HMSAction } from './HMSAction';
+import { HMSException } from './HMSException';
+import { HMSSignalMethod } from '../signal/jsonrpc/models';
+export declare const ErrorFactory: {
+    WebSocketConnectionErrors: {
+        FailedToConnect(action: HMSAction, description?: string): HMSException;
+        WebSocketConnectionLost(action: HMSAction, description?: string): HMSException;
+        AbnormalClose(action: HMSAction, description?: string): HMSException;
+    };
+    APIErrors: {
+        ServerErrors(code: number, action: HMSAction, description?: string, isTerminal?: boolean): HMSException;
+        EndpointUnreachable(action: HMSAction, description?: string): HMSException;
+        InvalidTokenFormat(action: HMSAction, description?: string): HMSException;
+        InitConfigNotAvailable(action: HMSAction, description?: string): HMSException;
+    };
+    TracksErrors: {
+        GenericTrack(action: HMSAction, description?: string): HMSException;
+        CantAccessCaptureDevice(action: HMSAction, deviceInfo: string, description?: string): HMSException;
+        DeviceNotAvailable(action: HMSAction, deviceInfo: string, description?: string): HMSException;
+        DeviceInUse(action: HMSAction, deviceInfo: string, description?: string): HMSException;
+        DeviceLostMidway(action: HMSAction, deviceInfo: string, description?: string): HMSException;
+        NothingToReturn(action: HMSAction, description?: string, message?: string): HMSException;
+        InvalidVideoSettings(action: HMSAction, description?: string): HMSException;
+        AutoplayBlocked(action: HMSAction, description?: string): HMSException;
+        CodecChangeNotPermitted(action: HMSAction, description?: string): HMSException;
+        OverConstrained(action: HMSAction, deviceInfo: string, description?: string): HMSException;
+        NoAudioDetected(action: HMSAction, description?: string): HMSException;
+        SystemDeniedPermission(action: HMSAction, deviceInfo: string, description?: string): HMSException;
+        CurrentTabNotShared(): HMSException;
+        AudioPlaybackError(description: string): HMSException;
+        SelectedDeviceMissing(deviceType: string): HMSException;
+    };
+    WebrtcErrors: {
+        CreateOfferFailed(action: HMSAction, description?: string): HMSException;
+        CreateAnswerFailed(action: HMSAction, description?: string): HMSException;
+        SetLocalDescriptionFailed(action: HMSAction, description?: string): HMSException;
+        SetRemoteDescriptionFailed(action: HMSAction, description?: string): HMSException;
+        ICEFailure(action: HMSAction, description?: string, isTerminal?: boolean): HMSException;
+        ICEDisconnected(action: HMSAction, description?: string): HMSException;
+        StatsFailed(action: HMSAction, description?: string): HMSException;
+    };
+    WebsocketMethodErrors: {
+        ServerErrors(code: number, action: HMSAction | HMSSignalMethod, description: string): HMSException;
+        AlreadyJoined(action: HMSAction, description?: string): HMSException;
+        CannotJoinPreviewInProgress(action: HMSAction, description?: string): HMSException;
+    };
+    GenericErrors: {
+        NotConnected(action: HMSAction, description?: string): HMSException;
+        Signalling(action: HMSAction, description: string): HMSException;
+        Unknown(action: HMSAction, description: string): HMSException;
+        NotReady(action: HMSAction, description?: string): HMSException;
+        JsonParsingFailed(action: HMSAction, jsonMessage: string, description?: string): HMSException;
+        TrackMetadataMissing(action: HMSAction, description?: string): HMSException;
+        RTCTrackMissing(action: HMSAction, description?: string): HMSException;
+        PeerMetadataMissing(action: HMSAction, description?: string): HMSException;
+        ValidationFailed(message: string, entity?: any): HMSException;
+        InvalidRole(action: HMSAction, description: string): HMSException;
+        PreviewAlreadyInProgress(action: HMSAction, description?: string): HMSException;
+        LocalStorageAccessDenied(description?: string): HMSException;
+        MissingMediaDevices(): HMSException;
+        MissingRTCPeerConnection(): HMSException;
+    };
+    MediaPluginErrors: {
+        PlatformNotSupported(action: HMSAction, description?: string): HMSException;
+        InitFailed(action: HMSAction, description?: string): HMSException;
+        ProcessingFailed(action: HMSAction, description?: string): HMSException;
+        AddAlreadyInProgress(action: HMSAction, description?: string): HMSException;
+        DeviceNotSupported(action: HMSAction, description?: string): HMSException;
+    };
+    PlaylistErrors: {
+        NoEntryToPlay(action: HMSAction, description: string): HMSException;
+        NoEntryPlaying(action: HMSAction, description: string): HMSException;
+    };
+};

package/dist/error/HMSAction.d.ts

@@ -0,0 +1,19 @@
+export declare enum HMSAction {
+    NONE = "NONE",
+    TRACK = "TRACK",
+    INIT = "INIT",
+    GET_TOKEN = "GET_TOKEN",
+    PUBLISH = "PUBLISH",
+    UNPUBLISH = "UNPUBLISH",
+    JOIN = "JOIN",
+    SUBSCRIBE = "SUBSCRIBE",
+    DATA_CHANNEL_SEND = "DATA_CHANNEL_SEND",
+    RESTART_ICE = "RESTART_ICE",
+    VIDEO_PLUGINS = "VIDEO_PLUGINS",
+    AUDIO_PLUGINS = "AUDIO_PLUGINS",
+    AUTOPLAY = "AUTOPLAY",
+    RECONNECT_SIGNAL = "RECONNECT_SIGNAL",
+    VALIDATION = "VALIDATION",
+    PLAYLIST = "PLAYLIST",
+    PREVIEW = "PREVIEW"
+}

package/dist/error/HMSException.d.ts

@@ -0,0 +1,23 @@
+import { HMSAction } from './HMSAction';
+import { IAnalyticsPropertiesProvider } from '../analytics/IAnalyticsPropertiesProvider';
+import { HMSSignalMethod } from '../signal/jsonrpc/models';
+export declare class HMSException extends Error implements IAnalyticsPropertiesProvider {
+    readonly code: number;
+    name: string;
+    message: string;
+    description: string;
+    isTerminal: boolean;
+    action: string;
+    nativeError?: Error;
+    constructor(code: number, name: string, action: HMSAction | HMSSignalMethod, message: string, description: string, isTerminal?: boolean);
+    toAnalyticsProperties(): {
+        error_name: string;
+        error_code: number;
+        error_message: string;
+        error_description: string;
+        action: string;
+        is_terminal: boolean;
+    };
+    addNativeError(error: Error): void;
+    toString(): string;
+}

package/dist/error/utils.d.ts

@@ -0,0 +1,9 @@
+import { HMSException } from './HMSException';
+export declare enum HMSGetMediaActions {
+    UNKNOWN = "unknown(video or audio)",
+    AUDIO = "audio",
+    VIDEO = "video",
+    AV = "audio, video",
+    SCREEN = "screen"
+}
+export declare function BuildGetMediaError(err: Error, deviceInfo: string): HMSException;

package/dist/events/EventBus.d.ts

@@ -0,0 +1,51 @@
+import { HMSInternalEvent } from './HMSInternalEvent';
+import AnalyticsEvent from '../analytics/AnalyticsEvent';
+import { HMSException } from '../error/HMSException';
+import { HMSDeviceChangeEvent, HMSRole } from '../interfaces';
+import { HMSLocalAudioTrack, HMSLocalVideoTrack, HMSRemoteAudioTrack, HMSRemoteVideoTrack, HMSWebrtcStats } from '../internal';
+import { PolicyParams } from '../notification-manager/HMSNotifications';
+import { HMSRemotePeer } from '../sdk/models/peer';
+import { ITrackAudioLevelUpdate } from '../utils/track-audio-level-monitor';
+export declare class EventBus {
+    private eventEmitter;
+    readonly deviceChange: HMSInternalEvent<HMSDeviceChangeEvent>;
+    readonly localAudioEnabled: HMSInternalEvent<{
+        enabled: boolean;
+        track: HMSLocalAudioTrack;
+    }>;
+    readonly localVideoEnabled: HMSInternalEvent<{
+        enabled: boolean;
+        track: HMSLocalVideoTrack;
+    }>;
+    /**
+     * Emitter which processes raw RTC stats from rtcStatsUpdate and calls client callback
+     */
+    readonly statsUpdate: HMSInternalEvent<HMSWebrtcStats>;
+    readonly trackDegraded: HMSInternalEvent<HMSRemoteVideoTrack>;
+    readonly trackRestored: HMSInternalEvent<HMSRemoteVideoTrack>;
+    /**
+     * Emits audio level updates for audio tracks(used with local track in preview)
+     */
+    readonly trackAudioLevelUpdate: HMSInternalEvent<ITrackAudioLevelUpdate>;
+    readonly audioPluginFailed: HMSInternalEvent<HMSException>;
+    readonly localAudioSilence: HMSInternalEvent<{
+        track: HMSLocalAudioTrack;
+    }>;
+    readonly analytics: HMSInternalEvent<AnalyticsEvent>;
+    readonly policyChange: HMSInternalEvent<PolicyParams>;
+    readonly localRoleUpdate: HMSInternalEvent<{
+        oldRole: HMSRole;
+        newRole: HMSRole;
+    }>;
+    readonly audioTrackUpdate: HMSInternalEvent<{
+        track: HMSRemoteAudioTrack;
+        enabled: boolean;
+    }>;
+    readonly audioTrackAdded: HMSInternalEvent<{
+        track: HMSRemoteAudioTrack;
+        peer: HMSRemotePeer;
+    }>;
+    readonly audioTrackRemoved: HMSInternalEvent<HMSRemoteAudioTrack>;
+    readonly autoplayError: HMSInternalEvent<HMSException>;
+    readonly leave: HMSInternalEvent<HMSException | undefined>;
+}

package/dist/events/HMSInternalEvent.d.ts

@@ -0,0 +1,13 @@
+import type { WaitForFilter } from 'eventemitter2';
+import { EventEmitter2 as EventEmitter } from 'eventemitter2';
+export declare class HMSInternalEvent<T> {
+    private eventName;
+    private eventEmitter;
+    constructor(eventName: string, eventEmitter: EventEmitter);
+    publish: (event?: T) => void;
+    subscribe: (fn: (event: T) => void | Promise<void>) => void;
+    subscribeOnce: (fn: (event: T) => void | Promise<void>) => void;
+    unsubscribe: (fn: (event: T) => void | Promise<void>) => void;
+    waitFor: (predicate: WaitForFilter) => import("eventemitter2").CancelablePromise<any[]>;
+    removeAllListeners: () => void;
+}