@webex/plugin-meetings 3.0.0-beta.3 → 3.0.0-beta.300

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

@@ -0,0 +1,194 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+export type ReachabilityMetrics = {
+    reachability_public_udp_success: number;
+    reachability_public_udp_failed: number;
+    reachability_public_tcp_success: number;
+    reachability_public_tcp_failed: number;
+    reachability_vmn_udp_success: number;
+    reachability_vmn_udp_failed: number;
+    reachability_vmn_tcp_success: number;
+    reachability_vmn_tcp_failed: number;
+};
+export type TransportResult = {
+    reachable?: 'true' | 'false';
+    latencyInMilliseconds?: string;
+    clientMediaIPs?: string[];
+    untested?: 'true';
+};
+type ReachabilityResult = {
+    udp: TransportResult;
+    tcp: TransportResult;
+    xtls: {
+        untested: 'true';
+    };
+};
+export type ReachabilityResults = Record<string, ReachabilityResult>;
+type InternalReachabilityResults = Record<string, ReachabilityResult & {
+    isVideoMesh?: boolean;
+}>;
+export type ICECandidateResult = {
+    clusterId: string;
+    isVideoMesh: boolean;
+    elapsed?: string | null;
+    publicIPs?: string[];
+};
+/**
+ * @class Reachability
+ * @export
+ */
+export default class Reachability {
+    namespace: string;
+    webex: object;
+    reachabilityRequest: any;
+    clusterLatencyResults: any;
+    /**
+     * Creates an instance of Reachability.
+     * @param {object} webex
+     * @memberof Reachability
+     */
+    constructor(webex: object);
+    /**
+     * fetches reachability data
+     * @returns {Object} reachability data
+     * @public
+     * @async
+     * @memberof Reachability
+     */
+    gatherReachability(): Promise<InternalReachabilityResults>;
+    /**
+     * Returns statistics about last reachability results. The returned value is an object
+     * with a flat list of properties so that it can be easily sent with metrics
+     *
+     * @returns {Promise} Promise with metrics values, it never rejects/throws.
+     */
+    getReachabilityMetrics(): Promise<ReachabilityMetrics>;
+    /**
+     * Reachability results as an object in the format that backend expects
+     *
+     * @returns {any} reachability results that need to be sent to the backend
+     */
+    getReachabilityResults(): Promise<ReachabilityResults | undefined>;
+    /**
+     * fetches reachability data and checks for cluster reachability
+     * @returns {boolean}
+     * @public
+     * @memberof Reachability
+     */
+    isAnyPublicClusterReachable(): Promise<boolean>;
+    /**
+     * Generate peerConnection config settings
+     * @param {object} cluster
+     * @returns {object} peerConnectionConfig
+     * @private
+     * @memberof Reachability
+     */
+    private buildPeerConnectionConfig;
+    /**
+     * Creates an RTCPeerConnection
+     * @param {object} cluster
+     * @returns {RTCPeerConnection} peerConnection
+     * @private
+     * @memberof Reachability
+     */
+    private createPeerConnection;
+    /**
+     * Gets total elapsed time
+     * @param {RTCPeerConnection} peerConnection
+     * @returns {Number} Milliseconds
+     * @private
+     * @memberof Reachability
+     */
+    private getElapsedTime;
+    /**
+     * creates offer and generates localSDP
+     * @param {object} clusterList cluster List
+     * @returns {Promise} Reachability latency results
+     * @private
+     * @memberof Reachability
+     */
+    private getLocalSDPForClusters;
+    /**
+     * Get list of all unreachable clusters
+     * @returns {array} Unreachable clusters
+     * @private
+     * @memberof Reachability
+     */
+    private getUnreachablClusters;
+    /**
+     * Attach an event handler for the icegatheringstatechange
+     * event and measure latency.
+     * @param {RTCPeerConnection} peerConnection
+     * @returns {undefined}
+     * @private
+     * @memberof Reachability
+     */
+    private handleIceGatheringStateChange;
+    /**
+     * Attach an event handler for the icecandidate
+     * event and measure latency.
+     * @param {RTCPeerConnection} peerConnection
+     * @returns {undefined}
+     * @private
+     * @memberof Reachability
+     */
+    private handleOnIceCandidate;
+    /**
+     * An event handler on an RTCPeerConnection when the state of the ICE
+     * candidate gathering process changes. Used to measure connection
+     * speed.
+     * @private
+     * @param {RTCPeerConnection} peerConnection
+     * @param {boolean} isVideoMesh
+     * @returns {Promise}
+     */
+    private iceGatheringState;
+    /**
+     * Make a log of unreachable clusters.
+     * @returns {undefined}
+     * @private
+     * @memberof Reachability
+     */
+    private logUnreachableClusters;
+    /**
+     * Calculates time to establish connection
+     * @param {Array<ICECandidateResult>} iceResults iceResults
+     * @returns {object} reachabilityMap
+     * @protected
+     * @memberof Reachability
+     */
+    protected parseIceResultsToInternalReachabilityResults(iceResults: Array<ICECandidateResult>): InternalReachabilityResults;
+    /**
+     * fetches reachability data
+     * @param {object} clusterList
+     * @returns {Promise<InternalReachabilityResults>} reachability check results
+     * @private
+     * @memberof Reachability
+     */
+    private performReachabilityCheck;
+    /**
+     * Adds public IP (client media IPs)
+     * @param {RTCPeerConnection} peerConnection
+     * @param {string} publicIP
+     * @returns {void}
+     */
+    protected addPublicIP(peerConnection: RTCPeerConnection, publicIP?: string | null): void;
+    /**
+     * Records latency and closes the peerConnection
+     * @param {RTCPeerConnection} peerConnection
+     * @param {number} elapsed Latency in milliseconds
+     * @returns {undefined}
+     * @private
+     * @memberof Reachability
+     */
+    private setLatencyAndClose;
+    /**
+     * utility function
+     * @returns {undefined}
+     * @private
+     * @memberof Reachability
+     */
+    private setup;
+}
+export {};

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

@@ -0,0 +1,39 @@
+import { IP_VERSION } from '../constants';
+export interface ClusterNode {
+    isVideoMesh: boolean;
+    udp: Array<string>;
+    tcp: Array<string>;
+    xtls: Array<string>;
+}
+export type ClusterList = {
+    [key: string]: ClusterNode;
+};
+/**
+ * @class ReachabilityRequest
+ */
+declare class ReachabilityRequest {
+    webex: any;
+    /**
+     * Creates an instance of ReachabilityRequest.
+     * @param {object} webex
+     * @memberof ReachabilityRequest
+     */
+    constructor(webex: object);
+    /**
+     * Gets the cluster information
+     *
+     * @param {IP_VERSION} ipVersion information about current ip network we're on
+     * @returns {Promise}
+     */
+    getClusters: (ipVersion?: IP_VERSION) => Promise<{
+        clusters: ClusterList;
+        joinCookie: any;
+    }>;
+    /**
+     * gets remote SDP For Clusters
+     * @param {Object} localSDPList localSDPs for the cluster
+     * @returns {Object}
+     */
+    remoteSDPForClusters: (localSDPList: object) => any;
+}
+export default ReachabilityRequest;

package/dist/types/reactions/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const REACTION_RELAY_TYPES: {
+    readonly REACTION: "react";
+};

package/dist/types/reactions/reactions.d.ts

@@ -0,0 +1,4 @@
+import { Reaction, ReactionServerType, SkinTone, SkinToneType } from './reactions.type';
+declare const Reactions: Record<ReactionServerType, Reaction>;
+declare const SkinTones: Record<SkinToneType, SkinTone>;
+export { Reactions, SkinTones };

package/dist/types/reactions/reactions.type.d.ts

@@ -0,0 +1,52 @@
+import { REACTION_RELAY_TYPES } from './constants';
+export type EmoticonData = {
+    type: string;
+    codepoints?: string;
+    shortcodes?: string;
+};
+export type SkinTone = EmoticonData;
+export type Reaction = EmoticonData & {
+    tone?: SkinTone;
+};
+export declare enum ReactionServerType {
+    smile = "smile",
+    sad = "sad",
+    wow = "wow",
+    haha = "haha",
+    celebrate = "celebrate",
+    clap = "clap",
+    thumb_up = "thumb_up",
+    thumb_down = "thumb_down",
+    heart = "heart",
+    fire = "fire",
+    prayer = "prayer",
+    speed_up = "speed_up",
+    slow_down = "slow_down"
+}
+export declare enum SkinToneType {
+    normal = "normal",
+    light = "light",
+    medium_light = "medium_light",
+    medium = "medium",
+    medium_dark = "medium_dark",
+    dark = "dark"
+}
+export type Sender = {
+    participantId: string;
+};
+export type ProcessedReaction = {
+    reaction: Reaction;
+    sender: {
+        id: Sender['participantId'];
+        name: string;
+    };
+};
+type RelayEventData = {
+    relayType: (typeof REACTION_RELAY_TYPES)['REACTION'];
+    reaction: Reaction;
+    sender: Sender;
+};
+export type RelayEvent = {
+    data: RelayEventData;
+};
+export {};

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 stream.
+     *
+     * @param {string} reason a {@link SHARE_STOPPED_REASON}
+     * @returns {undefined}
+     * @private
+     * @memberof ReconnectionManager
+     */
+    private stopLocalShareStream;
+    /**
+     * @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,207 @@
+import { SELF_POLICY } from '../constants';
+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 {Object}
+     * @private
+     * @memberof RecordingInfo
+     */
+    private selfUserPolicies;
+    /**
+     * @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
+     * @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 {Object} selfUserPolicies
+     * @returns {void}
+     * @public
+     * @memberof RecordingController
+     */
+    setUserPolicy(selfUserPolicies: Record<SELF_POLICY, boolean>): 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,14 @@
+import { SELF_POLICY } from '../constants';
+import RecordingAction from './enums';
+declare const _default: {
+    canUserStart: (displayHints: string[], userPolicies: Record<SELF_POLICY, boolean>) => boolean;
+    canUserPause: (displayHints: string[], userPolicies: Record<SELF_POLICY, boolean>) => boolean;
+    canUserResume: (displayHints: string[], userPolicies: Record<SELF_POLICY, boolean>) => boolean;
+    canUserStop: (displayHints: string[], userPolicies: Record<SELF_POLICY, boolean>) => boolean;
+    deriveRecordingStates: (action: RecordingAction) => {
+        recording: boolean;
+        paused: boolean;
+    };
+    extractLocusId: (url: string) => string;
+};
+export default _default;