@webex/plugin-meetings 3.0.0-stream-classes.4 → 3.0.0

package/dist/{types/meeting → meeting}/index.d.ts

@@ -10,7 +10,7 @@ import MediaProperties from '../media/properties';
 import ReconnectionManager from '../reconnection-manager';
 import MeetingRequest from './request';
 import Members from '../members/index';
-import Transcription from '../transcription';
+import { NETWORK_STATUS } from '../constants';
 import { ReceiveSlotManager } from '../multistream/receiveSlotManager';
 import { MediaRequestManager } from '../multistream/mediaRequestManager';
 import { Configuration as RemoteMediaManagerConfiguration, RemoteMediaManager } from '../multistream/remoteMediaManager';
@@ -19,6 +19,34 @@ import InMeetingActions from './in-meeting-actions';
 import RecordingController from '../recording-controller';
 import ControlsOptionsManager from '../controls-options-manager';
 import { LocusMediaRequest } from './locusMediaRequest';
+export type CaptionData = {
+    id: string;
+    isFinal: boolean;
+    translations: Array<string>;
+    text: string;
+    currentCaptionLanguage: string;
+    timestamp: string;
+    speaker: string;
+};
+export type Transcription = {
+    languageOptions: {
+        captionLanguages?: string;
+        maxLanguages?: number;
+        spokenLanguages?: Array<string>;
+        currentCaptionLanguage?: string;
+        requestedCaptionLanguage?: string;
+        currentSpokenLanguage?: string;
+    };
+    status: string;
+    isListening: boolean;
+    commandText: string;
+    captions: Array<CaptionData>;
+    showCaptionBox: boolean;
+    transcribingRequestStatus: string;
+    isCaptioning: boolean;
+    speakerProxy: Map<string, any>;
+    interimCaptions: Map<string, CaptionData>;
+};
 export type LocalStreams = {
     microphone?: LocalMicrophoneStream;
     camera?: LocalCameraStream;
@@ -37,6 +65,11 @@ export type AddMediaOptions = {
     bundlePolicy?: BundlePolicy;
     allowMediaInLobby?: boolean;
 };
+export type CallStateForMetrics = {
+    correlationId?: string;
+    joinTrigger?: string;
+    loginType?: string;
+};
 export declare const MEDIA_UPDATE_TYPE: {
     TRANSCODED_MEDIA_CONNECTION: string;
     SHARE_FLOOR_REQUEST: string;
@@ -47,6 +80,12 @@ export declare enum ScreenShareFloorStatus {
     GRANTED = "floor_request_granted",
     RELEASED = "floor_released"
 }
+type FetchMeetingInfoParams = {
+    password?: string;
+    captchaCode?: string;
+    extraParams?: Record<string, any>;
+    sendCAevents?: boolean;
+};
 /**
  * MediaDirection
  * @typedef {Object} MediaDirection
@@ -299,8 +338,9 @@ export default class Meeting extends StatelessWebexPlugin {
     breakouts: any;
     simultaneousInterpretation: any;
     annotation: any;
+    webinar: any;
     conversationUrl: string;
-    correlationId: string;
+    callStateForMetrics: CallStateForMetrics;
     destination: string;
     destinationType: string;
     deviceUrl: string;
@@ -355,8 +395,9 @@ export default class Meeting extends StatelessWebexPlugin {
     };
     meetingInfoFailureReason: string;
     meetingInfoFailureCode?: number;
+    meetingInfoExtraParams?: Record<string, any>;
     networkQualityMonitor: NetworkQualityMonitor;
-    networkStatus: string;
+    networkStatus?: NETWORK_STATUS;
     passwordStatus: string;
     queuedMediaUpdates: any[];
     recording: any;
@@ -366,6 +407,7 @@ export default class Meeting extends StatelessWebexPlugin {
     requiredCaptcha: any;
     receiveSlotManager: ReceiveSlotManager;
     selfUserPolicies: any;
+    enforceVBGImagesURL: string;
     shareStatus: string;
     screenShareFloorState: ScreenShareFloorStatus;
     statsAnalyzer: StatsAnalyzer;
@@ -385,7 +427,9 @@ export default class Meeting extends StatelessWebexPlugin {
     meetingJoinUrl: any;
     meetingNumber: any;
     meetingState: any;
-    permissionToken: any;
+    permissionToken: string;
+    permissionTokenPayload: any;
+    permissionTokenReceivedLocalTime: number;
     resourceId: any;
     resourceUrl: string;
     selfId: string;
@@ -397,7 +441,17 @@ export default class Meeting extends StatelessWebexPlugin {
     environment: string;
     namespace: string;
     allowMediaInLobby: boolean;
+    localShareInstanceId: string;
+    remoteShareInstanceId: string;
+    turnDiscoverySkippedReason: string;
+    turnServerUsed: boolean;
+    areVoiceaEventsSetup: boolean;
+    voiceaListenerCallbacks: object;
+    private retriedWithTurnServer;
     private sendSlotManager;
+    private deferSDPAnswer?;
+    private sdpResponseTimer?;
+    private hasMediaConnectionConnectedAtLeastOnce;
     /**
      * @param {Object} attrs
      * @param {Object} options
@@ -417,30 +471,79 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {Boolean}
      */
     isLocusCall(): boolean;
+    /**
+     * Getter - Returns callStateForMetrics.correlationId
+     * @returns {string}
+     */
+    get correlationId(): string;
+    /**
+     * Setter - sets callStateForMetrics.correlationId
+     * @param {string} correlationId
+     */
+    set correlationId(correlationId: string);
+    /**
+     * Set meeting info and trigger `MEETING_INFO_AVAILABLE` event
+     * @param {any} info
+     * @param {string} [meetingLookupUrl] Lookup url, defined when the meeting info fetched
+     * @returns {void}
+     */
+    private setMeetingInfo;
+    /**
+     * Add pre-fetched meeting info
+     *
+     * The passed meeting info should be be complete, e.g.: fetched after password or captcha provided
+     *
+     * @param {Object} meetingInfo - Complete meeting info
+     * @param {FetchMeetingInfoParams} fetchParams - Fetch parameters for validation
+     * @param {String|undefined} meetingLookupUrl - Lookup url, defined when the meeting info fetched
+     * @returns {Promise<void>}
+     */
+    injectMeetingInfo(meetingInfo: any, fetchParams: FetchMeetingInfoParams, meetingLookupUrl: string | undefined): Promise<void>;
+    /**
+     * Validate fetch parameters and clear the fetchMeetingInfoTimeout timeout
+     *
+     * @param {FetchMeetingInfoParams} fetchParams - fetch parameters for validation
+     * @param {String} caller - Name of the caller for logging
+     *
+     * @returns {Promise<void>}
+     * @private
+     */
+    private prepForFetchMeetingInfo;
+    /**
+     * Internal method for fetching meeting info
+     *
+     * @returns {Promise}
+     */
+    private fetchMeetingInfoInternal;
+    /**
+     * Refreshes the meeting info permission token (it's required for joining meetings)
+     *
+     * @param {string} [reason] used for metrics and logging purposes (optional)
+     * @returns {Promise}
+     */
+    refreshPermissionToken(reason?: string): Promise<void>;
     /**
      * Fetches meeting information.
      * @param {Object} options
      * @param {String} [options.password] optional
      * @param {String} [options.captchaCode] optional
+     * @param {Boolean} [options.sendCAevents] optional - Whether to submit Call Analyzer events or not. Default: false.
      * @public
      * @memberof Meeting
      * @returns {Promise}
      */
-    fetchMeetingInfo({ password, captchaCode, extraParams, }: {
-        password?: string;
-        captchaCode?: string;
-        extraParams?: Record<string, any>;
-    }): Promise<void>;
+    fetchMeetingInfo(options: FetchMeetingInfoParams): Promise<void>;
     /**
      * Checks if the supplied password/host key is correct. It returns a promise with information whether the
      * password and captcha code were correct or not.
      * @param {String} password - this can be either a password or a host key, can be undefined if only captcha was required
      * @param {String} captchaCode - can be undefined if captcha was not required by the server
+     * @param {Boolean} sendCAevents - whether Call Analyzer events should be sent when fetching meeting information
      * @public
      * @memberof Meeting
      * @returns {Promise<{isPasswordValid: boolean, requiredCaptcha: boolean, failureReason: MEETING_INFO_FAILURE_REASON}>}
      */
-    verifyPassword(password: string, captchaCode: string): Promise<{
+    verifyPassword(password: string, captchaCode: string, sendCAevents?: boolean): Promise<{
         isPasswordValid: boolean;
         requiredCaptcha: any;
         failureReason: string;
@@ -486,6 +589,13 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     private setUpInterpretationListener;
+    /**
+     * Set up the listeners for captions
+     * @returns {undefined}
+     * @private
+     * @memberof Meeting
+     */
+    private setUpVoiceaListeners;
     /**
      * Set up the locus info listener for meetings disconnected due to inactivity
      * @returns {undefined}
@@ -509,7 +619,7 @@ export default class Meeting extends StatelessWebexPlugin {
     private setUpLocusFullStateListener;
     /**
      * sets the network status on meeting object
-     * @param {String} networkStatus
+     * @param {NETWORK_STATUS} networkStatus
      * @private
      * @returns {undefined}
      * @memberof Meeting
@@ -727,24 +837,36 @@ export default class Meeting extends StatelessWebexPlugin {
     /**
      * Sets the meeting info on the class instance
      * @param {Object} meetingInfo
-     * @param {Object} meetingInfo.body
-     * @param {String} meetingInfo.body.conversationUrl
-     * @param {String} meetingInfo.body.locusUrl
-     * @param {String} meetingInfo.body.sipUri
-     * @param {Object} meetingInfo.body.owner
+     * @param {String} meetingInfo.conversationUrl
+     * @param {String} meetingInfo.locusUrl
+     * @param {String} meetingInfo.sipUri
+     * @param {String} [meetingInfo.sipUrl]
+     * @param {String} [meetingInfo.sipMeetingUri]
+     * @param {String} [meetingInfo.meetingNumber]
+     * @param {String} [meetingInfo.meetingJoinUrl]
+     * @param {String} [meetingInfo.hostId]
+     * @param {String} [meetingInfo.permissionToken]
+     * @param {String} [meetingInfo.channel]
+     * @param {Object} meetingInfo.owner
      * @param {Object | String} destination locus object with meeting data or destination string (sip url, meeting link, etc)
+     * @param {Object | String} errors Meeting info request error
      * @returns {undefined}
      * @private
      * @memberof Meeting
      */
     parseMeetingInfo(meetingInfo: {
-        body: {
-            conversationUrl: string;
-            locusUrl: string;
-            sipUri: string;
-            owner: object;
-        };
-    } | any, destination?: object | string | null): void;
+        conversationUrl: string;
+        locusUrl: string;
+        sipUri: string;
+        owner: object;
+        sipUrl?: string;
+        sipMeetingUri?: string;
+        meetingNumber?: string;
+        meetingJoinUrl?: string;
+        hostId?: string;
+        permissionToken?: string;
+        channel?: string;
+    }, destination?: object | string | null, errors?: any): void;
     /**
      * Indicates whether policy can be applied
      * @returns {boolean}
@@ -759,10 +881,16 @@ export default class Meeting extends StatelessWebexPlugin {
     private updateMeetingActions;
     /**
      * Sets the self user policies based on the contents of the permission token
+     * @returns {void}
+     */
+    setSelfUserPolicies(): void;
+    /**
+     * Sets the permission token payload on the class instance
+     *
      * @param {String} permissionToken
      * @returns {void}
      */
-    setSelfUserPolicies(permissionToken: string): void;
+    setPermissionTokenPayload(permissionToken: string): void;
     /**
      * Sets the sip uri on the class instance
      * uses meeting info as precedence
@@ -820,7 +948,7 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {undefined}
      * @memberof Meeting
      */
-    closeRemoteStreams(): Promise<[any, any, any, any]>;
+    closeRemoteStreams(): Promise<[any, any, any]>;
     /**
      * Stores the reference to a new microphone stream, sets up the required event listeners
      * on it, cleans up previous stream, etc.
@@ -879,13 +1007,21 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     unsetPeerConnections(): void;
     /**
-     * Convenience method to set the correlation id for the Meeting
-     * @param {String} id correlation id to set on the class
+     * Convenience method to set the correlation id for the callStateForMetrics
+     * @param {String} id correlation id to set on the callStateForMetrics
      * @returns {undefined}
-     * @private
+     * @public
      * @memberof Meeting
      */
-    private setCorrelationId;
+    setCorrelationId(id: string): void;
+    /**
+     * Update the callStateForMetrics
+     * @param {CallStateForMetrics} callStateForMetrics updated values for callStateForMetrics
+     * @returns {undefined}
+     * @public
+     * @memberof Meeting
+     */
+    updateCallStateForMetrics(callStateForMetrics: CallStateForMetrics): void;
     /**
      * Enqueue request for screenshare floor and set the status to pending
      * @returns {Promise}
@@ -940,7 +1076,10 @@ export default class Meeting extends StatelessWebexPlugin {
     joinWithMedia(options?: {
         joinOptions?: any;
         mediaOptions?: AddMediaOptions;
-    }): any;
+    }): Promise<{
+        join: any;
+        media: void;
+    }>;
     /**
      * Initiates the reconnection of the media in the meeting
      *
@@ -962,17 +1101,26 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     isReactionsSupported(): boolean;
     /**
-     * Monitor the Low-Latency Mercury (LLM) web socket connection on `onError` and `onClose` states
-     * @private
-     * @returns {void}
+     * sets Caption language for the meeting
+     * @param {string} language
+     * @returns {Promise}
      */
-    private monitorTranscriptionSocketConnection;
+    setCaptionLanguage(language: string): Promise<unknown>;
     /**
-     * Request for a WebSocket Url, open and monitor the WebSocket connection
-     * @private
+     * sets Spoken language for the meeting
+     * @param {string} language
+     * @returns {Promise}
+     */
+    setSpokenLanguage(language: string): Promise<unknown>;
+    /**
+     * This method will enable the transcription for the current meeting if the meeting has enabled/supports Webex Assistant
+     * @param {Object} options object with spokenlanguage setting
+     * @public
      * @returns {Promise<void>} a promise to open the WebSocket connection
      */
-    private receiveTranscription;
+    startTranscription(options?: {
+        spokenLanguage?: string;
+    }): Promise<void>;
     /**
      * Callback called when a relay event is received from meeting LLM Connection
      * @param {RelayEvent} e Event object coming from LLM Connection
@@ -981,11 +1129,10 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     private processRelayEvent;
     /**
-     * stop recieving Transcription by closing
-     * the web socket connection properly
+     * This method stops receiving transcription for the current meeting
      * @returns {void}
      */
-    stopReceivingTranscription(): void;
+    stopTranscription(): void;
     /**
      * triggers an event to notify that the user
      * will not receive any more transcription
@@ -1005,7 +1152,7 @@ export default class Meeting extends StatelessWebexPlugin {
      *             if joining as host on second loop, pass pin and pass moderator if joining as guest on second loop
      * Scenario D: Joining any other way (sip, pstn, conversationUrl, link just need to specify resourceId)
      */
-    join(options?: any): any;
+    join(options?: any): Promise<any>;
     /**
      * Connects to low latency mercury and reconnects if the address has changed
      * It will also disconnect if called when the meeting has ended
@@ -1075,6 +1222,12 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {void}
      */
     handleRoapFailure: (error: any) => void;
+    /**
+     * This function makes sure we send the right metrics when local and remote SDPs are processed/generated
+     *
+     * @returns {undefined}
+     */
+    setupSdpListeners: () => void;
     setupMediaConnectionListeners: () => void;
     /**
      * Registers for all required StatsAnalyzer events
@@ -1103,20 +1256,122 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {void}
      */
     forwardEvent(eventEmitter: any, eventTypeToForward: any, meetingEventType: any): void;
+    /**
+     * Sets up all the references to local streams in this.mediaProperties before creating media connection
+     * and before TURN discovery, so that the correct mute state is sent with TURN discovery roap messages.
+     *
+     * @private
+     * @param {LocalStreams} localStreams
+     * @returns {Promise<void>}
+     */
+    private setUpLocalStreamReferences;
+    /**
+     * Calls mediaProperties.waitForMediaConnectionConnected() and sends CA client.ice.end metric on failure
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private waitForMediaConnectionConnected;
+    /**
+     * Enables statsAnalyser if config allows it
+     *
+     * @private
+     * @returns {void}
+     */
+    private createStatsAnalyzer;
+    /**
+     * Handles device logging
+     *
+     * @private
+     * @static
+     * @returns {Promise<void>}
+     */
+    private static handleDeviceLogging;
+    /**
+     * Returns a promise. This promise is created once the local sdp offer has been successfully created and is resolved
+     * once the remote sdp answer has been received.
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private waitForRemoteSDPAnswer;
+    /**
+     * Calls establishMediaConnection with isForced = true to force turn discovery to happen
+     *
+     * @private
+     * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+     * @param {BundlePolicy} [bundlePolicy]
+     * @returns {Promise<void>}
+     */
+    private retryEstablishMediaConnectionWithForcedTurnDiscovery;
+    /**
+     * Does relevant clean up before retrying to establish media connection
+     * and performs the retry with forced turn discovery
+     *
+     * @private
+     * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+     * @param {BundlePolicy} [bundlePolicy]
+     * @returns {Promise<void>}
+     */
+    private retryWithForcedTurnDiscovery;
+    /**
+     * If waitForMediaConnectionConnected() fails when we haven't done turn discovery then we
+     * attempt to establish a media connection again, but this time using turn discovery. If we
+     * used turn discovery on the first pass we do not attempt connection again.
+     *
+     * @private
+     * @param {Error} error
+     * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+     * @param {BundlePolicy} [bundlePolicy]
+     * @returns {Promise<void>}
+     */
+    private handleWaitForMediaConnectionConnectedError;
+    /**
+     * Does TURN discovery, SDP offer/answer exhange, establishes ICE connection and DTLS handshake.
+     *
+     * @private
+     * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+     * @param {BundlePolicy} [bundlePolicy]
+     * @param {boolean} [isForced] - let isForced be true to do turn discovery regardless of reachability results
+     * @returns {Promise<void>}
+     */
+    private establishMediaConnection;
+    /**
+     * Cleans up stats analyzer, peer connection, and turns off listeners
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private cleanUpOnAddMediaFailure;
+    /**
+     * Sends stats report, closes peer connection and cleans up any media connection
+     * related things before trying to establish media connection again with turn server
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private cleanUpBeforeRetryWithTurnServer;
     /**
      * Creates a media connection to the server. Media connection is required for sending or receiving any audio/video.
      *
      * @param {AddMediaOptions} options
-     * @returns {Promise}
+     * @returns {Promise<void>}
      * @public
      * @memberof Meeting
      */
-    addMedia(options?: AddMediaOptions): Promise<any>;
+    addMedia(options?: AddMediaOptions): Promise<void>;
     /**
      * Informs if the peer connection is in a state that can be updated with updateMedia (audio/video/share)
      * @returns {Boolean}
      */
     canUpdateMedia(): boolean;
+    /**
+     *  media failed, so collect a stats report from webrtc using the wcme connection to grab the rtc stats report
+     * send a webrtc telemetry dump to the configured server using the internal media core check metrics configured callback
+     * @param {String} callFrom - the function calling this function, optional.
+     * @returns {Promise<void>}
+     */
+    private forceSendStatsReport;
     /**
      * Enqueues a media update operation.
      * @param {String} mediaUpdateType one of MEDIA_UPDATE_TYPE values
@@ -1383,6 +1638,14 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {undefined}
      */
     private handleShareAudioStreamEnded;
+    /**
+     * Functionality for when a share video is muted or unmuted.
+     * @private
+     * @memberof Meeting
+     * @param {boolean} muted
+     * @returns {undefined}
+     */
+    private handleShareVideoStreamMuteStateChange;
     /**
      * Functionality for when a share video is ended.
      * @private
@@ -1420,7 +1683,7 @@ export default class Meeting extends StatelessWebexPlugin {
      *
      * @returns {string} one of 'attendee','host','cohost', returns the user type of the current user
      */
-    getCurUserType(): "host" | "cohost" | "attendee";
+    getCurUserType(): "host" | "cohost" | "presenter" | "attendee";
     /**
      * End the current meeting for all
      * @returns {Promise}
@@ -1516,4 +1779,28 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {Promise}
      */
     unpublishStreams(streams: LocalStream[]): Promise<void>;
+    /**
+     * Gets permission token expiry information including timeLeft, expiryTime, currentTime
+     * (from the time the function has been fired)
+     *
+     * @returns {object} permissionTokenExpiryInfo
+     * @returns {number} permissionTokenExpiryInfo.timeLeft The time left for token to expire
+     * @returns {number} permissionTokenExpiryInfo.expiryTime The expiry time of permission token from the server
+     * @returns {number} permissionTokenExpiryInfo.currentTime The current time of the local machine
+     */
+    getPermissionTokenExpiryInfo(): {
+        timeLeft: number;
+        expiryTime: number;
+        currentTime: number;
+    };
+    /**
+     * Check if there is enough time left till the permission token expires
+     * If not - refresh the permission token
+     *
+     * @param {number} threshold - time in seconds
+     * @param {string} reason - reason for refreshing the permission token
+     * @returns {Promise<void>}
+     */
+    checkAndRefreshPermissionToken(threshold: number, reason: string): Promise<void>;
 }
+export {};