@webex/plugin-meetings 3.0.0-stream-classes.5 → 3.0.0-test.1

package/dist/types/meeting/index.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { StatelessWebexPlugin } from '@webex/webex-core';
 import { ClientEvent, ClientEventLeaveReason } from '@webex/internal-plugin-metrics';
+import { MediaType } from '@webex/internal-media-core';
 import { LocalStream, LocalCameraStream, LocalDisplayStream, LocalSystemAudioStream, LocalMicrophoneStream } from '@webex/media-helpers';
 import { StatsAnalyzer } from '../statsAnalyzer';
 import NetworkQualityMonitor from '../networkQualityMonitor';
@@ -11,6 +12,7 @@ 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';
@@ -37,6 +39,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 +54,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 +312,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 +369,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 +381,7 @@ export default class Meeting extends StatelessWebexPlugin {
     requiredCaptcha: any;
     receiveSlotManager: ReceiveSlotManager;
     selfUserPolicies: any;
+    enforceVBGImagesURL: string;
     shareStatus: string;
     screenShareFloorState: ScreenShareFloorStatus;
     statsAnalyzer: StatsAnalyzer;
@@ -387,18 +403,27 @@ export default class Meeting extends StatelessWebexPlugin {
     meetingState: any;
     permissionToken: string;
     permissionTokenPayload: any;
+    permissionTokenReceivedLocalTime: number;
     resourceId: any;
     resourceUrl: string;
     selfId: string;
     state: any;
-    localAudioStreamMuteStateHandler: (muted: boolean) => void;
-    localVideoStreamMuteStateHandler: (muted: boolean) => void;
+    localAudioStreamMuteStateHandler: () => void;
+    localVideoStreamMuteStateHandler: () => void;
     localOutputTrackChangeHandler: () => void;
     roles: any[];
     environment: string;
     namespace: string;
     allowMediaInLobby: boolean;
+    localShareInstanceId: string;
+    remoteShareInstanceId: string;
+    turnDiscoverySkippedReason: string;
+    turnServerUsed: boolean;
+    private retriedWithTurnServer;
     private sendSlotManager;
+    private deferSDPAnswer?;
+    private sdpResponseTimer?;
+    private hasMediaConnectionConnectedAtLeastOnce;
     /**
      * @param {Object} attrs
      * @param {Object} options
@@ -418,30 +443,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;
@@ -510,7 +584,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
@@ -728,24 +802,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}
@@ -827,7 +913,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.
@@ -886,13 +972,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
+     */
+    setCorrelationId(id: string): void;
+    /**
+     * Update the callStateForMetrics
+     * @param {CallStateForMetrics} callStateForMetrics updated values for callStateForMetrics
+     * @returns {undefined}
+     * @public
      * @memberof Meeting
      */
-    private setCorrelationId;
+    updateCallStateForMetrics(callStateForMetrics: CallStateForMetrics): void;
     /**
      * Enqueue request for screenshare floor and set the status to pending
      * @returns {Promise}
@@ -947,7 +1041,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
      *
@@ -1012,7 +1109,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
@@ -1082,6 +1179,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
@@ -1110,20 +1213,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
@@ -1390,6 +1595,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
@@ -1493,6 +1706,13 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {Promise<void>}
      */
     private updateTranscodedMediaConnection;
+    /**
+     * set sending named media group which the audio should send to
+     * @param {MediaType} mediaType of the stream
+     * @param {number} languageCode of the stream
+     * @returns {void}
+     */
+    setSendNamedMediaGroup(mediaType: MediaType, languageCode?: number): void;
     /**
      * Publishes a stream.
      *
@@ -1524,10 +1744,27 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     unpublishStreams(streams: LocalStream[]): Promise<void>;
     /**
-     * Gets the time left in seconds till the permission token expires
+     * Gets permission token expiry information including timeLeft, expiryTime, currentTime
      * (from the time the function has been fired)
      *
-     * @returns {number} time left in seconds
+     * @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>}
      */
-    getPermissionTokenTimeLeftInSec(): number | undefined;
+    checkAndRefreshPermissionToken(threshold: number, reason: string): Promise<void>;
 }
+export {};

package/dist/types/meeting/muteState.d.ts

@@ -72,7 +72,7 @@ export declare class MuteState {
      * @param {Boolean} [mute] true for muting, false for unmuting request
      * @returns {void}
      */
-    handleLocalStreamMuteStateChange(meeting?: object, mute?: boolean): void;
+    handleLocalStreamMuteStateChange(meeting?: any): void;
     /**
      * Applies the current mute state to the local stream (by enabling or disabling it accordingly)
      *
@@ -116,12 +116,6 @@ export declare class MuteState {
      * @returns {Promise}
      */
     private sendRemoteMuteRequestToServer;
-    /** Sets the mute state of the local stream according to what server thinks is our state
-     * @param {Object} meeting - the meeting object
-     * @param {ServerMuteReason} serverMuteReason - reason why we're applying server mute to the local stream
-     * @returns {void}
-     */
-    private applyServerMuteToLocalStream;
     /** Applies the current value for unmute allowed to the underlying stream
      *
      * @param {Meeting} meeting
@@ -147,7 +141,7 @@ export declare class MuteState {
      * @param {Object} [meeting] the meeting object
      * @returns {undefined}
      */
-    handleServerLocalUnmuteRequired(meeting?: object): void;
+    handleServerLocalUnmuteRequired(meeting?: any): void;
     /**
      * Returns true if the user is locally or remotely muted.
      * It only checks the mute status, ignoring the fact whether audio/video is enabled.

package/dist/types/meeting/request.d.ts

@@ -202,6 +202,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
      * @param {String} options.deviceUrl Url of a device
      * @param {String} options.resourceId Populated if you are paired to a device
      * @param {String} options.uri floor grant uri
+     * @param {String} options.shareInstanceId id for current share
      * @returns {Promise}
      */
     changeMeetingFloor(options: {
@@ -211,6 +212,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         resourceId: string;
         uri: string;
         annotationInfo: AnnotationInfo;
+        shareInstanceId: string;
     } | any): any;
     /**
      * Sends a request to the DTMF endpoint to send tones

package/dist/types/meeting/util.d.ts

@@ -98,5 +98,21 @@ declare const MeetingUtil: {
     generateLocusDeltaRequest: (originalMeeting: any) => (originalOptions: any) => any;
     selfSupportsFeature: (feature: SELF_POLICY, userPolicies: Record<SELF_POLICY, boolean>) => boolean;
     parseInterpretationInfo: (meeting: any, meetingInfo: any) => void;
+    /**
+     * Returns a CA-recognized error payload for the specified raw error message/reason.
+     *
+     * New errors can be added to this function for handling in the future
+     *
+     * @param {String} reason the raw error message
+     * @returns {Array<object>} an array of payload objects
+     */
+    getChangeMeetingFloorErrorPayload: (reason: string) => {
+        fatal: boolean;
+        category: string;
+        errorCode: number;
+        errorDescription: string;
+        name: string;
+        shownToUser: boolean;
+    }[];
 };
 export default MeetingUtil;

package/dist/types/meeting-info/index.d.ts

@@ -49,6 +49,12 @@ export default class MeetingInfo {
      * Fetches meeting info from the server
      * @param {String} destination one of many different types of destinations to look up info for
      * @param {String} [type] to match up with the destination value
+     * @param {String} [password] meeting password
+     * @param {Object} [captchaInfo] captcha code and id
+     * @param {String} [installedOrgID]
+     * @param {String} [locusId]
+     * @param {Object} [extraParams]
+     * @param {Boolean} [options] meeting Id and whether Call Analyzer events should be sent
      * @returns {Promise} returns a meeting info object
      * @public
      * @memberof MeetingInfo
@@ -58,5 +64,6 @@ export default class MeetingInfo {
         id: string;
     }, installedOrgID?: any, locusId?: any, extraParams?: object, options?: {
         meetingId?: string;
+        sendCAevents?: boolean;
     }): any;
 }

package/dist/types/meeting-info/meeting-info-v2.d.ts

@@ -118,5 +118,6 @@ export default class MeetingInfoV2 {
         id: string;
     }, installedOrgID?: any, locusId?: any, extraParams?: object, options?: {
         meetingId?: string;
+        sendCAevents?: boolean;
     }): Promise<any>;
 }

package/dist/types/meetings/collection.d.ts

@@ -28,4 +28,13 @@ export default class MeetingCollection extends Collection {
      * @memberof MeetingCollection
      */
     getActiveBreakoutLocus(breakoutUrl: string): any;
+    /**
+     * Gets the meeting that has a webrtc media connection
+     * NOTE: this function assumes there is no more than 1 such meeting
+     *
+     * @returns {Meeting} first meeting found, else undefined
+     * @public
+     * @memberof MeetingCollection
+     */
+    getActiveWebrtcMeeting(): any;
 }