@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.104

package/dist/types/reconnection-manager/index.d.ts

@@ -0,0 +1,126 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+import Meeting from '../meeting';
+/**
+ * @export
+ * @class ReconnectionManager
+ */
+export default class ReconnectionManager {
+    autoRejoinEnabled: any;
+    iceState: any;
+    maxRejoinAttempts: any;
+    meeting: any;
+    rejoinAttempts: any;
+    shareStatus: any;
+    status: any;
+    tryCount: any;
+    webex: any;
+    /**
+     * @param {Meeting} meeting
+     */
+    constructor(meeting: Meeting);
+    /**
+     * @public
+     * @memberof ReconnectionManager
+     * @returns {void}
+     */
+    resetReconnectionTimer(): void;
+    /**
+     * Sets the iceState to connected and clears any disconnect timeouts and
+     * related timeout data within the iceState.
+     *
+     * @returns {undefined}
+     * @public
+     * @memberof ReconnectionManager
+     */
+    iceReconnected(): void;
+    /**
+     * Set the iceState to disconnected and generates a timeout that waits for the
+     * iceState to reconnect and then resolves. If the ice state is already
+     * processing a reconnect, it immediately resolves. Rejects if the timeout
+     * duration is reached.
+     *
+     * @returns {Promise<undefined>}
+     * @public
+     * @memberof ReconnectionManager
+     */
+    waitForIceReconnect(): Promise<void>;
+    /**
+     * @returns {undefined}
+     * @public
+     * @memberof ReconnectionManager
+     */
+    reset(): void;
+    /**
+     * @returns {undefined}
+     * @public
+     * @memberof ReconnectionManager
+     */
+    cleanUp(): void;
+    /**
+     * Stop the local share track.
+     *
+     * @param {string} reason a {@link SHARE_STOPPED_REASON}
+     * @returns {undefined}
+     * @private
+     * @memberof ReconnectionManager
+     */
+    private stopLocalShareTrack;
+    /**
+     * @public
+     * @memberof ReconnectionManager
+     * @returns {Boolean} true if reconnection operation is in progress
+     */
+    isReconnectInProgress(): boolean;
+    /**
+     * @returns {Boolean}
+     * @throws {ReconnectionError}
+     * @private
+     * @memberof ReconnectionManager
+     */
+    private validate;
+    /**
+     * Initiates a media reconnect for the active meeting
+     * @param {Object} reconnectOptions
+     * @param {boolean} [reconnectOptions.networkDisconnect=false] indicates if a network disconnect event happened
+     * @param {boolean} [reconnectOptions.networkRetry=false] indicates if we are retrying the reconnect
+     * @returns {Promise}
+     * @public
+     * @memberof ReconnectionManager
+     */
+    reconnect({ networkDisconnect, networkRetry, }?: {
+        networkDisconnect?: boolean;
+        networkRetry?: boolean;
+    }): any;
+    /**
+     * @param {Object} reconnectOptions
+     * @param {boolean} [reconnectOptions.networkDisconnect=false] indicates if a network disconnect event happened
+     * @returns {Promise}
+     * @throws {NeedsRetryError}
+     * @private
+     * @memberof ReconnectionManager
+     */
+    private executeReconnection;
+    /**
+     * Rejoins a meeting after detecting the member was in a LEFT state
+     *
+     * @async
+     * @param {boolean} wasSharing
+     * @returns {Promise}
+     */
+    rejoinMeeting(wasSharing?: boolean): Promise<void>;
+    /**
+     * @returns {Promise}
+     * @private
+     * @memberof ReconnectionManager
+     */
+    reconnectMedia(): Promise<void>;
+    /**
+     * Attempt to Reconnect Mercury Websocket
+     * @returns {Promise}
+     * @private
+     * @memberof ReconnectionManager
+     */
+    private reconnectMercuryWebSocket;
+}

package/dist/types/recording-controller/enums.d.ts

@@ -0,0 +1,7 @@
+declare enum RecordingAction {
+    Start = "Start",
+    Stop = "Stop",
+    Pause = "Pause",
+    Resume = "Resume"
+}
+export default RecordingAction;

package/dist/types/recording-controller/index.d.ts

@@ -0,0 +1,193 @@
+import MeetingRequest from '../meeting/request';
+/**
+ * @description Recording manages the recording functionality of the meeting object, there should only be one instantation of recording per meeting
+ * @export
+ * @private
+ * @class Recording
+ */
+export default class RecordingController {
+    /**
+     * @instance
+     * @type {MeetingRequest}
+     * @private
+     * @memberof RecordingController
+     */
+    private request;
+    /**
+     * @instance
+     * @type {Array}
+     * @private
+     * @memberof RecordingInfo
+     */
+    private displayHints;
+    /**
+     * @instance
+     * @type {string}
+     * @private
+     * @memberof RecordingInfo
+     */
+    private serviceUrl;
+    /**
+     * @instance
+     * @type {string}
+     * @private
+     * @memberof RecordingInfo
+     */
+    private sessionId;
+    /**
+     * @instance
+     * @type {string}
+     * @private
+     * @memberof RecordingInfo
+     */
+    private locusUrl;
+    /**
+     * @instance
+     * @type {string}
+     * @private
+     * @memberof RecordingInfo
+     */
+    private locusId;
+    /**
+     * @param {MeetingRequest} request
+     * @param {Object} options
+     * @constructor
+     * @memberof RecordingController
+     */
+    constructor(request: MeetingRequest, options?: {
+        serviceUrl?: string;
+        sessionId: string;
+        locusUrl: string;
+        displayHints?: Array<string>;
+    });
+    /**
+     * @param {MeetingRequest} request
+     * @param {LocusInfo} info
+     * @returns {void}
+     * @private
+     * @memberof RecordingController
+     */
+    private initialize;
+    /**
+     * @param {Object} options
+     * @returns {void}
+     * @public
+     * @memberof RecordingController
+     */
+    set(options?: {
+        serviceUrl?: string;
+        sessionId: string;
+        locusUrl: string;
+        displayHints?: Array<string>;
+    }): void;
+    /**
+     * @param {string} url
+     * @returns {void}
+     * @public
+     * @memberof RecordingController
+     */
+    setLocusUrl(url: string): void;
+    /**
+     * @param {Array} hints
+     * @returns {void}
+     * @public
+     * @memberof RecordingController
+     */
+    setDisplayHints(hints: Array<string>): void;
+    /**
+     * @param {string} id
+     * @returns {void}
+     * @public
+     * @memberof RecordingController
+     */
+    setSessionId(id: string): void;
+    /**
+     * @param {string} url
+     * @returns {void}
+     * @public
+     * @memberof RecordingController
+     */
+    setServiceUrl(url: string): void;
+    /**
+     * @returns {string}
+     * @public
+     * @memberof RecordingController
+     */
+    getLocusUrl(): string;
+    /**
+     * @returns {string}
+     * @public
+     * @memberof RecordingController
+     */
+    getLocusId(): string;
+    /**
+     * @returns {string}
+     * @public
+     * @memberof RecordingController
+     */
+    getSessionId(): string;
+    /**
+     * @returns {string}
+     * @public
+     * @memberof RecordingController
+     */
+    getServiceUrl(): string;
+    /**
+     * @returns {Array}
+     * @public
+     * @memberof RecordingController
+     */
+    getDisplayHints(): string[];
+    /**
+     * @param {Object} options
+     * @returns {void}
+     * @private
+     * @memberof RecordingController
+     */
+    private extract;
+    /**
+     * @param {RecordingAction} action
+     * @private
+     * @memberof RecordingController
+     * @returns {Promise}
+     */
+    private recordingService;
+    /**
+     * @param {RecordingAction} action
+     * @private
+     * @memberof RecordingController
+     * @returns {Promise}
+     */
+    private recordingControls;
+    /**
+     * @param {RecordingAction} action
+     * @private
+     * @memberof RecordingController
+     * @returns {Promise}
+     */
+    private recordingFacade;
+    /**
+     * @private
+     * @memberof RecordingController
+     * @returns {Promise}
+     */
+    startRecording(): Promise<any>;
+    /**
+     * @private
+     * @memberof RecordingController
+     * @returns {Promise}
+     */
+    stopRecording(): Promise<any>;
+    /**
+     * @private
+     * @memberof RecordingController
+     * @returns {Promise}
+     */
+    pauseRecording(): Promise<any>;
+    /**
+     * @private
+     * @memberof RecordingController
+     * @returns {Promise}
+     */
+    resumeRecording(): Promise<any>;
+}

package/dist/types/recording-controller/util.d.ts

@@ -0,0 +1,13 @@
+import RecordingAction from './enums';
+declare const _default: {
+    canUserStart: (displayHints: string[]) => boolean;
+    canUserPause: (displayHints: string[]) => boolean;
+    canUserResume: (displayHints: string[]) => boolean;
+    canUserStop: (displayHints: string[]) => boolean;
+    deriveRecordingStates: (action: RecordingAction) => {
+        recording: boolean;
+        paused: boolean;
+    };
+    extractLocusId: (url: string) => string;
+};
+export default _default;

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

@@ -0,0 +1,77 @@
+import { StatelessWebexPlugin } from '@webex/webex-core';
+import Meeting from '../meeting';
+/**
+ * Roap options
+ * @typedef {Object} RoapOptions
+ * @property {String} sdp
+ * @property {Meeting} meeting
+ * @property {Number} seq
+ * @property {Number} tieBreaker
+ *  @property {Boolean} reconnect
+ */
+/**
+ * @typedef {Object} SeqOptions
+ * @property {String} correlationId
+ * @property {String} mediaId
+ * @property {Number} seq
+ */
+/**
+ * @class Roap
+ * @export
+ * @private
+ */
+export default class Roap extends StatelessWebexPlugin {
+    attrs: any;
+    lastRoapOffer: any;
+    options: any;
+    roapHandler: any;
+    roapRequest: any;
+    turnDiscovery: any;
+    /**
+     *
+     * @param {Object} attrs
+     * @param {Object} options
+     */
+    constructor(attrs: any, options: any);
+    /**
+     *
+     * @param {SeqOptions} options
+     * @returns {null}
+     * @memberof Roap
+     */
+    sendRoapOK(options: any): Promise<any>;
+    /**
+     * Sends a ROAP answer...
+     * @param {SeqOptions} options
+     * @param {Boolean} options.audioMuted
+     * @param {Boolean} options.videoMuted
+     * @returns {Promise}
+     * @memberof Roap
+     */
+    sendRoapAnswer(options: any): any;
+    /**
+     * Sends a ROAP error...
+     * @param {Object} options
+     * @returns {Promise}
+     * @memberof Roap
+     */
+    sendRoapError(options: any): any;
+    /**
+     * sends a roap media request
+     * @param {RoapOptions} options
+     * @returns {Promise}
+     * @memberof Roap
+     */
+    sendRoapMediaRequest(options: any): any;
+    /**
+     * Performs a TURN server discovery procedure, which involves exchanging
+     * some roap messages with the server. This exchange has to be done before
+     * any other roap messages are sent
+     *
+     * @param {Meeting} meeting
+     * @param {Boolean} isReconnecting should be set to true if this is a new
+     *                                 media connection just after a reconnection
+     * @returns {Promise}
+     */
+    doTurnDiscovery(meeting: Meeting, isReconnecting: boolean): any;
+}

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

@@ -0,0 +1,38 @@
+import { StatelessWebexPlugin } from '@webex/webex-core';
+/**
+ * @class RoapRequest
+ */
+export default class RoapRequest extends StatelessWebexPlugin {
+    /**
+     * Returns reachability data.
+     * @param {Object} localSdp
+     * @returns {Object}
+     */
+    attachReachabilityData(localSdp: any): Promise<{
+        localSdp: any;
+        joinCookie: any;
+    }>;
+    /**
+     * Sends a ROAP message
+     * @param {Object} options
+     * @param {Object} options.roapMessage
+     * @param {String} options.locusSelfUrl
+     * @param {String} options.mediaId
+     * @param {String} options.correlationId
+     * @param {Boolean} options.audioMuted
+     * @param {Boolean} options.videoMuted
+     * @param {String} options.meetingId
+     * @param {Boolean} options.preferTranscoding
+     * @returns {Promise} returns the response/failure of the request
+     */
+    sendRoap(options: {
+        roapMessage: any;
+        locusSelfUrl: string;
+        mediaId: string;
+        correlationId: string;
+        audioMuted: boolean;
+        videoMuted: boolean;
+        meetingId: string;
+        preferTranscoding?: boolean;
+    }): Promise<any>;
+}

package/dist/types/roap/turnDiscovery.d.ts

@@ -0,0 +1,88 @@
+import RoapRequest from './request';
+import Meeting from '../meeting';
+/**
+ * Handles the process of finding out TURN server information from Linus.
+ * This is achieved by sending a TURN_DISCOVERY_REQUEST.
+ */
+export default class TurnDiscovery {
+    private roapRequest;
+    private defer?;
+    private turnInfo;
+    private responseTimer?;
+    /**
+     * Constructor
+     *
+     * @param {RoapRequest} roapRequest
+     */
+    constructor(roapRequest: RoapRequest);
+    /**
+     * waits for TURN_DISCOVERY_RESPONSE message to arrive
+     *
+     * @returns {Promise}
+     * @private
+     * @memberof Roap
+     */
+    private waitForTurnDiscoveryResponse;
+    /**
+     * handles TURN_DISCOVERY_RESPONSE roap message
+     *
+     * @param {Object} roapMessage
+     * @returns {void}
+     * @public
+     * @memberof Roap
+     */
+    handleTurnDiscoveryResponse(roapMessage: object): void;
+    /**
+     * sends the TURN_DISCOVERY_REQUEST roap request
+     *
+     * @param {Meeting} meeting
+     * @param {Boolean} isReconnecting
+     * @returns {Promise}
+     * @private
+     * @memberof Roap
+     */
+    sendRoapTurnDiscoveryRequest(meeting: Meeting, isReconnecting: boolean): Promise<void>;
+    /**
+     * Sends the OK message that server expects to receive
+     * after it sends us TURN_DISCOVERY_RESPONSE
+     *
+     * @param {Meeting} meeting
+     * @returns {Promise}
+     */
+    sendRoapOK(meeting: Meeting): Promise<any>;
+    /**
+     * Gets the reason why reachability is skipped.
+     *
+     * @param {Meeting} meeting
+     * @returns {Promise<string>} Promise with empty string if reachability is not skipped or a reason if it is skipped
+     */
+    private getSkipReason;
+    /**
+     * Checks if TURN discovery is skipped.
+     *
+     * @param {Meeting} meeting
+     * @returns {Boolean} true if TURN discovery is being skipped, false if it is being done
+     */
+    isSkipped(meeting: any): Promise<boolean>;
+    /**
+     * Retrieves TURN server information from the backend by doing
+     * a roap message exchange:
+     * client                             server
+     *  | -----TURN_DISCOVERY_REQUEST-----> |
+     *  | <----TURN_DISCOVERY_RESPONSE----- |
+     *  | --------------OK----------------> |
+     *
+     * This TURN discovery roap exchange is always done with seq=0.
+     * The RoapMediaConnection SDP exchange always starts with seq=1,
+     * so it works fine no matter if TURN discovery is done or not.
+     *
+     * @param {Meeting} meeting
+     * @param {Boolean} isReconnecting should be set to true if this is a new
+     *                                 media connection just after a reconnection
+     * @returns {Promise}
+     */
+    doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean): Promise<{
+        turnServerInfo: any;
+        turnDiscoverySkippedReason: any;
+    }>;
+}

package/dist/types/statsAnalyzer/global.d.ts

@@ -0,0 +1,36 @@
+declare const STATS_DEFAULT: {
+    encryption: string;
+    bandwidth: {
+        systemBandwidth: number;
+        sentPerSecond: number;
+        encodedPerSecond: number;
+        helper: {
+            audioBytesSent: number;
+            videoBytestSent: number;
+        };
+        speed: number;
+    };
+    results: {};
+    connectionType: {
+        systemNetworkType: string;
+        systemIpAddress: string;
+        local: {
+            candidateType: any[];
+            transport: any[];
+            ipAddress: any[];
+            networkType: any[];
+        };
+        remote: {
+            candidateType: any[];
+            transport: any[];
+            ipAddress: any[];
+            networkType: any[];
+        };
+    };
+    resolutions: {};
+    internal: {
+        remote: {};
+        candidates: {};
+    };
+};
+export default STATS_DEFAULT;