@webex/plugin-meetings 3.0.0-beta.16 → 3.0.0-beta.161

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,36 @@
+import { StatelessWebexPlugin } from '@webex/webex-core';
+import { LocusMediaRequest } from '../meeting/locusMediaRequest';
+/**
+ * @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 {String} options.meetingId
+     * @returns {Promise} returns the response/failure of the request
+     */
+    sendRoap(options: {
+        roapMessage: any;
+        locusSelfUrl: string;
+        mediaId: string;
+        meetingId: string;
+        locusMediaRequest?: LocusMediaRequest;
+    }): Promise<{
+        mediaConnections: any;
+        locus: any;
+    }>;
+}

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

@@ -0,0 +1,91 @@
+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<{
+        mediaConnections: any;
+        locus: 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;

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

@@ -0,0 +1,200 @@
+/// <reference types="node" />
+import EventsScope from '../common/events/events-scope';
+import { ReceiveSlot } from '../multistream/receiveSlot';
+export declare const EVENTS: {
+    MEDIA_QUALITY: string;
+    LOCAL_MEDIA_STARTED: string;
+    LOCAL_MEDIA_STOPPED: string;
+    REMOTE_MEDIA_STARTED: string;
+    REMOTE_MEDIA_STOPPED: string;
+};
+type ReceiveSlotCallback = (csi: number) => ReceiveSlot | undefined;
+/**
+ * Stats Analyzer class that will emit events based on detected quality
+ *
+ * @export
+ * @class StatsAnalyzer
+ * @extends {EventsScope}
+ */
+export declare class StatsAnalyzer extends EventsScope {
+    config: any;
+    correlationId: any;
+    lastEmittedStartStopEvent: any;
+    lastMqaDataSent: any;
+    lastStatsResults: any;
+    meetingMediaStatus: any;
+    mqaInterval: NodeJS.Timeout;
+    mqaSentCount: any;
+    networkQualityMonitor: any;
+    mediaConnection: any;
+    statsInterval: NodeJS.Timeout;
+    statsResults: any;
+    statsStarted: any;
+    receiveSlotCallback: ReceiveSlotCallback;
+    /**
+     * Creates a new instance of StatsAnalyzer
+     * @constructor
+     * @public
+     * @param {Object} config SDK Configuration Object
+     * @param {Function} receiveSlotCallback Callback used to access receive slots.
+     * @param {Object} networkQualityMonitor class for assessing network characteristics (jitter, packetLoss, latency)
+     * @param {Object} statsResults Default properties for stats
+     */
+    constructor(config: any, receiveSlotCallback?: ReceiveSlotCallback, networkQualityMonitor?: object, statsResults?: object);
+    /**
+     * Resets cumulative stats arrays.
+     *
+     * @public
+     * @memberof StatsAnalyzer
+     * @returns {void}
+     */
+    resetStatsResults(): void;
+    /**
+     * sets mediaStatus status for analyzing metrics
+     *
+     * @public
+     * @param {Object} status for the audio and video
+     * @memberof StatsAnalyzer
+     * @returns {void}
+     */
+    updateMediaStatus(status: object): void;
+    /**
+     * captures MQA data from media connection
+     *
+     * @public
+     * @memberof StatsAnalyzer
+     * @returns {void}
+     */
+    sendMqaData(): void;
+    /**
+     * updated the media connection when changed
+     *
+     * @private
+     * @memberof StatsAnalyzer
+     * @param {RoapMediaConnection} mediaConnection
+     * @returns {void}
+     */
+    updateMediaConnection(mediaConnection: any): void;
+    /**
+     * Starts the stats analyzer on interval
+     *
+     * @public
+     * @memberof StatsAnalyzer
+     * @param {RoapMediaConnection} mediaConnection
+     * @returns {Promise}
+     */
+    startAnalyzer(mediaConnection: any): any;
+    /**
+     * Cleans up the analyzer when done
+     *
+     * @public
+     * @memberof StatsAnalyzer
+     * @returns {void}
+     */
+    stopAnalyzer(): any;
+    /**
+     * Parse a single result of get stats
+     *
+     * @private
+     * @param {*} getStatsResult
+     * @param {String} type
+     * @param {boolean} isSender
+     * @returns {void}
+     * @memberof StatsAnalyzer
+     */
+    private parseGetStatsResult;
+    /**
+     * Filters the get stats results for types
+     * @private
+     * @param {Array} statsItem
+     * @param {String} type
+     * @param {boolean} isSender
+     * @returns {void}
+     */
+    filterAndParseGetStatsResults(statsItem: any, type: string, isSender: boolean): void;
+    /**
+     * parse the audio
+     * @param {String} result
+     * @param {boolean} type
+     * @returns {void}
+     */
+    parseAudioSource(result: any, type: any): void;
+    /**
+     * emits started/stopped events for local/remote media by checking
+     * if given values are increasing or not. The previousValue, currentValue
+     * params can be any numerical value like number of receive packets or
+     * decoded frames, etc.
+     *
+     * @private
+     * @param {string} mediaType
+     * @param {number} previousValue - value to compare
+     * @param {number} currentValue - value to compare (must be same type of value as previousValue)
+     * @param {boolean} isLocal - true if stats are for local media being sent out, false for remote media being received
+     * @memberof StatsAnalyzer
+     * @returns {void}
+     */
+    emitStartStopEvents: (mediaType: string, previousValue: number, currentValue: number, isLocal: boolean) => void;
+    /**
+     * compares current and previous stats to check if packets are not sent
+     *
+     * @private
+     * @memberof StatsAnalyzer
+     * @returns {void}
+     */
+    private compareLastStatsResult;
+    /**
+     * Does a `getStats` on all the transceivers and parses the results
+     *
+     * @private
+     * @memberof StatsAnalyzer
+     * @returns {Promise}
+     */
+    private getStatsAndParse;
+    /**
+     * Processes OutboundRTP stats result and stores
+     * @private
+     * @param {*} result
+     * @param {*} mediaType
+     * @returns {void}
+     */
+    private processOutboundRTPResult;
+    /**
+     * Processes InboundRTP stats result and stores
+     * @private
+     * @param {*} result
+     * @param {*} mediaType
+     * @returns {void}
+     */
+    private processInboundRTPResult;
+    /**
+     * Processes remote and local candidate result and stores
+     * @private
+     * @param {*} result
+     * @param {*} type
+     * @param {boolean} isSender
+     * @param {boolean} isRemote
+     *
+     * @returns {void}
+     */
+    parseCandidate: (result: any, type: any, isSender: boolean, isRemote: boolean) => void;
+    /**
+     * Process Track results
+     *
+     * @private
+     * @param {*} result
+     * @param {*} mediaType
+     * @returns {void}
+     * @memberof StatsAnalyzer
+     */
+    private processTrackResult;
+    /**
+     *
+     * @private
+     * @param {*} result
+     * @param {*} type
+     * @returns {void}
+     * @memberof StatsAnalyzer
+     */
+    compareSentAndReceived(result: any, type: any): void;
+}
+export {};

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

@@ -0,0 +1,24 @@
+export declare const getAudioReceiverMqa: ({ audioReceiver, statsResults, lastMqaDataSent, mediaType }: {
+    audioReceiver: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    mediaType: any;
+}) => void;
+export declare const getAudioSenderMqa: ({ audioSender, statsResults, lastMqaDataSent, mediaType }: {
+    audioSender: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    mediaType: any;
+}) => void;
+export declare const getVideoReceiverMqa: ({ videoReceiver, statsResults, lastMqaDataSent, mediaType }: {
+    videoReceiver: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    mediaType: any;
+}) => void;
+export declare const getVideoSenderMqa: ({ videoSender, statsResults, lastMqaDataSent, mediaType }: {
+    videoSender: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    mediaType: any;
+}) => void;