@webex/plugin-meetings 3.7.0 → 3.8.0

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

@@ -2,42 +2,11 @@
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
 import { Defer } from '@webex/common';
+import { IP_VERSION } from '../constants';
 import ReachabilityRequest, { ClusterList } from './request';
-import { ClusterReachability, ClusterReachabilityResult } from './clusterReachability';
+import { ClusterReachabilityResult, ClientMediaPreferences, ReachabilityMetrics, ReachabilityReportV0, ReachabilityReportV1, ReachabilityResults, ReachabilityResultsForBackend, GetClustersTrigger } from './reachability.types';
+import { ClusterReachability } from './clusterReachability';
 import EventsScope from '../common/events/events-scope';
-export type ReachabilityMetrics = {
-    reachability_public_udp_success: number;
-    reachability_public_udp_failed: number;
-    reachability_public_tcp_success: number;
-    reachability_public_tcp_failed: number;
-    reachability_public_xtls_success: number;
-    reachability_public_xtls_failed: number;
-    reachability_vmn_udp_success: number;
-    reachability_vmn_udp_failed: number;
-    reachability_vmn_tcp_success: number;
-    reachability_vmn_tcp_failed: number;
-    reachability_vmn_xtls_success: number;
-    reachability_vmn_xtls_failed: number;
-};
-/**
- * This is the type that matches what backend expects us to send to them. It is a bit weird, because
- * it uses strings instead of booleans and numbers, but that's what they require.
- */
-export type TransportResultForBackend = {
-    reachable?: 'true' | 'false';
-    latencyInMilliseconds?: string;
-    clientMediaIPs?: string[];
-    untested?: 'true';
-};
-export type ReachabilityResultForBackend = {
-    udp: TransportResultForBackend;
-    tcp: TransportResultForBackend;
-    xtls: TransportResultForBackend;
-};
-export type ReachabilityResultsForBackend = Record<string, ReachabilityResultForBackend>;
-export type ReachabilityResults = Record<string, ClusterReachabilityResult & {
-    isVideoMesh?: boolean;
-}>;
 /**
  * @class Reachability
  * @export
@@ -49,6 +18,8 @@ export default class Reachability extends EventsScope {
     clusterReachability: {
         [key: string]: ClusterReachability;
     };
+    minRequiredClusters?: number;
+    orpheusApiVersion?: number;
     reachabilityDefer?: Defer;
     vmnTimer?: ReturnType<typeof setTimeout>;
     publicCloudTimer?: ReturnType<typeof setTimeout>;
@@ -73,6 +44,8 @@ export default class Reachability extends EventsScope {
             xtls: number;
         };
     };
+    startTime: any;
+    totalDuration: any;
     protected lastTrigger?: string;
     /**
      * Creates an instance of Reachability.
@@ -82,11 +55,13 @@ export default class Reachability extends EventsScope {
     constructor(webex: object);
     /**
      * Fetches the list of media clusters from the backend
+     * @param {string} trigger - explains the reason for starting reachability, used by Orpheus
+     * @param {Object} previousReport - last reachability report
      * @param {boolean} isRetry
      * @private
      * @returns {Promise<{clusters: ClusterList, joinCookie: any}>}
      */
-    getClusters(isRetry?: boolean): Promise<{
+    getClusters(trigger: GetClustersTrigger, previousReport?: any, isRetry?: boolean): Promise<{
         clusters: ClusterList;
         joinCookie: any;
     }>;
@@ -98,6 +73,39 @@ export default class Reachability extends EventsScope {
      * @memberof Reachability
      */
     gatherReachability(trigger: string): Promise<ReachabilityResults>;
+    /**
+     * Gets the last join cookie we got from Orpheus
+     *
+     * @returns {Promise<Object>} join cookie
+     */
+    getJoinCookie(): Promise<any>;
+    /**
+     * Returns the reachability report that needs to be attached to the ROAP messages
+     * that we send to the backend.
+     *
+     * @returns {Promise<Object>}
+     */
+    getReachabilityReport(): Promise<{
+        joinCookie: any;
+        reachability?: ReachabilityReportV1;
+    } | {
+        reachability: ReachabilityReportV0;
+    }>;
+    /**
+     * This method is called when we don't succeed in reaching the minimum number of clusters
+     * required by Orpheus. It sends the results to Orpheus and gets a new list that it tries to reach again.
+     * @returns {Promise<ReachabilityResults>} reachability results
+     * @public
+     * @memberof Reachability
+     */
+    gatherReachabilityFallback(): Promise<void>;
+    /**
+     * Stops all reachability checks that are in progress
+     * @public
+     * @memberof Reachability
+     * @returns {void}
+     */
+    stopReachability(): void;
     /**
      * 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
@@ -142,6 +150,13 @@ export default class Reachability extends EventsScope {
      * @memberof Reachability
      */
     private getUnreachableClusters;
+    /**
+     * Gets the number of reachable clusters from last run reachability check
+     * @returns {number} reachable clusters count
+     * @private
+     * @memberof Reachability
+     */
+    private getNumberOfReachableClusters;
     /**
      * Make a log of unreachable clusters.
      * @returns {undefined}
@@ -165,6 +180,7 @@ export default class Reachability extends EventsScope {
     private areAllResultsReady;
     /**
      * Resolves the promise returned by gatherReachability() method
+     * @param {boolean} checkMinRequiredClusters - if true, it will check if we have reached the minimum required clusters and do a fallback if needed
      * @returns {void}
      */
     private resolveReachabilityPromise;
@@ -192,9 +208,10 @@ export default class Reachability extends EventsScope {
     /**
      * Sends a metric with all the statistics about how long reachability took
      *
+     * @param {boolean} aborted true if the reachability checks were aborted
      * @returns {void}
      */
-    protected sendMetric(): Promise<void>;
+    protected sendMetric(aborted?: boolean): Promise<void>;
     /**
      * Starts all the timers used for various timeouts
      *
@@ -214,10 +231,40 @@ export default class Reachability extends EventsScope {
      * @returns {void}
      */
     private resetResultCounters;
+    /**
+     * Clears the timer
+     *
+     * @param {string} timer name of the timer to clear
+     * @returns {void}
+     */
+    private clearTimer;
+    /**
+     * Aborts current checks that are in progress
+     *
+     * @returns {void}
+     */
+    private abortCurrentChecks;
     /**
      * Performs reachability checks for all clusters
      * @param {ClusterList} clusterList
      * @returns {Promise<void>} promise that's resolved as soon as the checks are started
      */
     private performReachabilityChecks;
+    /**
+     * Returns the clientMediaPreferences object that needs to be sent to the backend
+     * when joining a meeting
+     *
+     * @param {boolean} isMultistream
+     * @param {IP_VERSION} ipver
+     * @returns {Object}
+     */
+    getClientMediaPreferences(isMultistream: boolean, ipver?: IP_VERSION): Promise<ClientMediaPreferences>;
+    /**
+     * Returns the reachability report that needs to be attached to the ROAP messages
+     * that we send to the backend.
+     * It may return undefined, if reachability is not needed to be attached to ROAP messages (that's the case for v1 or Orpheus API)
+     *
+     * @returns {Promise<ReachabilityReportV0>} object that needs to be attached to Roap messages
+     */
+    getReachabilityReportToAttachToRoap(): Promise<ReachabilityReportV0 | undefined>;
 }

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

@@ -0,0 +1,64 @@
+import { IP_VERSION } from '../constants';
+export type TransportResult = {
+    result: 'reachable' | 'unreachable' | 'untested';
+    latencyInMilliseconds?: number;
+    clientMediaIPs?: string[];
+};
+export type ClusterReachabilityResult = {
+    udp: TransportResult;
+    tcp: TransportResult;
+    xtls: TransportResult;
+};
+export type ReachabilityMetrics = {
+    reachability_public_udp_success: number;
+    reachability_public_udp_failed: number;
+    reachability_public_tcp_success: number;
+    reachability_public_tcp_failed: number;
+    reachability_public_xtls_success: number;
+    reachability_public_xtls_failed: number;
+    reachability_vmn_udp_success: number;
+    reachability_vmn_udp_failed: number;
+    reachability_vmn_tcp_success: number;
+    reachability_vmn_tcp_failed: number;
+    reachability_vmn_xtls_success: number;
+    reachability_vmn_xtls_failed: number;
+};
+/**
+ * This is the type that matches what backend expects us to send to them. It is a bit weird, because
+ * it uses strings instead of booleans and numbers, but that's what they require.
+ */
+export type TransportResultForBackend = {
+    reachable?: 'true' | 'false';
+    latencyInMilliseconds?: string;
+    clientMediaIPs?: string[];
+    untested?: 'true';
+};
+export type ReachabilityResultForBackend = {
+    udp: TransportResultForBackend;
+    tcp: TransportResultForBackend;
+    xtls: TransportResultForBackend;
+};
+export type ReachabilityResultsForBackend = Record<string, ReachabilityResultForBackend>;
+export type ReachabilityResults = Record<string, ClusterReachabilityResult & {
+    isVideoMesh?: boolean;
+}>;
+export type ReachabilityReportV0 = ReachabilityResultsForBackend;
+export type ReachabilityReportV1 = {
+    version: 1;
+    result: {
+        usedDiscoveryOptions: {
+            'early-call-min-clusters': number;
+        };
+        metrics: {
+            'total-duration-ms': number;
+        };
+        tests: Record<string, ReachabilityResultForBackend>;
+    };
+};
+export interface ClientMediaPreferences {
+    ipver: IP_VERSION;
+    joinCookie: any;
+    preferTranscoding: boolean;
+    reachability?: ReachabilityReportV1;
+}
+export type GetClustersTrigger = 'startup' | 'early-call/no-min-reached';

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

@@ -1,4 +1,5 @@
 import { IP_VERSION } from '../constants';
+import { GetClustersTrigger } from './reachability.types';
 export interface ClusterNode {
     isVideoMesh: boolean;
     udp: Array<string>;
@@ -22,12 +23,15 @@ declare class ReachabilityRequest {
     /**
      * Gets the cluster information
      *
+     * @param {string} trigger that's passed to Orpheus
      * @param {IP_VERSION} ipVersion information about current ip network we're on
+     * @param {Object} previousReport last reachability result
      * @returns {Promise}
      */
-    getClusters: (ipVersion?: IP_VERSION) => Promise<{
+    getClusters: (trigger: GetClustersTrigger, ipVersion?: IP_VERSION, previousReport?: any) => Promise<{
         clusters: ClusterList;
         joinCookie: any;
+        discoveryOptions?: Record<string, any>;
     }>;
     /**
      * gets remote SDP For Clusters

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

@@ -1,7 +1,10 @@
-declare enum RecordingAction {
+export declare enum RecordingAction {
     Start = "Start",
     Stop = "Stop",
     Pause = "Pause",
     Resume = "Resume"
 }
-export default RecordingAction;
+export declare enum RecordingType {
+    Premise = "premise",
+    Cloud = "cloud"
+}

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

@@ -161,6 +161,7 @@ export default class RecordingController {
     private extract;
     /**
      * @param {RecordingAction} action
+     * @param {RecordingType} recordingType
      * @private
      * @memberof RecordingController
      * @returns {Promise}

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

@@ -1,10 +1,11 @@
 import { SELF_POLICY } from '../constants';
-import RecordingAction from './enums';
+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;
+    isPremiseRecordingEnabled: (displayHints: string[], userPolicies: Record<SELF_POLICY, boolean>) => boolean;
     deriveRecordingStates: (action: RecordingAction) => {
         recording: boolean;
         paused: boolean;

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

@@ -1,19 +1,9 @@
 import { StatelessWebexPlugin } from '@webex/webex-core';
-import { IP_VERSION } from '../constants';
 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
@@ -22,15 +12,13 @@ export default class RoapRequest extends StatelessWebexPlugin {
      * @param {String} options.mediaId
      * @param {String} options.correlationId
      * @param {String} options.meetingId
-     * @param {IP_VERSION} options.ipVersion only required for offers
      * @returns {Promise} returns the response/failure of the request
      */
     sendRoap(options: {
         roapMessage: any;
         locusSelfUrl: string;
         mediaId: string;
-        meetingId: string;
-        ipVersion?: IP_VERSION;
+        isMultistream: boolean;
         locusMediaRequest?: LocusMediaRequest;
     }): Promise<{
         mediaConnections: 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,217 @@
+/// <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;
+type MediaStatus = {
+    actual?: any;
+    expected?: any;
+};
+/**
+ * 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;
+    successfulCandidatePair: any;
+    localIpAddress: string;
+    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: MediaStatus): 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;
+    /**
+     * Returns the local IP address for diagnostics.
+     * this is the local IP of the interface used for the current media connection
+     * a host can have many local Ip Addresses
+     * @returns {string | undefined} The local IP address.
+     */
+    getLocalIpAddress(): string;
+    /**
+     * 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;
+    /**
+     * extracts the local Ip address from the statsResult object by looking at stats results candidates
+     * and matches that ID with the successful candidate pair. It looks at the type of local candidate it is
+     * and then extracts the IP address from the relatedAddress or address property based on conditions known in webrtc
+     * note, there are known incompatibilities and it is possible for this to set undefined, or for the IP address to be the public IP address
+     * for example, firefox does not set the relayProtocol, and if the user is behind a NAT it might be the public IP
+     * @private
+     * @param {string} successfulCandidatePairId - The ID of the successful candidate pair.
+     * @param {Object} candidates - the stats result candidates
+     * @returns {void}
+     */
+    extractAndSetLocalIpAddressInfoForDiagnostics: (successfulCandidatePairId: string, candidates: {
+        [key: string]: Record<string, unknown>;
+    }) => void;
+    /**
+     * 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;
+    /**
+     *
+     * @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,48 @@
+export declare const getAudioReceiverMqa: ({ audioReceiver, statsResults, lastMqaDataSent, baseMediaType, }: {
+    audioReceiver: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    baseMediaType: any;
+}) => void;
+export declare const getAudioReceiverStreamMqa: ({ audioReceiverStream, statsResults, lastMqaDataSent, mediaType, }: {
+    audioReceiverStream: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    mediaType: any;
+}) => void;
+export declare const getAudioSenderMqa: ({ audioSender, statsResults, lastMqaDataSent, baseMediaType }: {
+    audioSender: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    baseMediaType: any;
+}) => void;
+export declare const getAudioSenderStreamMqa: ({ audioSenderStream, statsResults, lastMqaDataSent, mediaType, }: {
+    audioSenderStream: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    mediaType: any;
+}) => void;
+export declare const getVideoReceiverMqa: ({ videoReceiver, statsResults, lastMqaDataSent, baseMediaType, }: {
+    videoReceiver: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    baseMediaType: any;
+}) => void;
+export declare const getVideoReceiverStreamMqa: ({ videoReceiverStream, statsResults, lastMqaDataSent, mediaType, }: {
+    videoReceiverStream: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    mediaType: any;
+}) => void;
+export declare const getVideoSenderMqa: ({ videoSender, statsResults, lastMqaDataSent, baseMediaType }: {
+    videoSender: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    baseMediaType: any;
+}) => void;
+export declare const getVideoSenderStreamMqa: ({ videoSenderStream, statsResults, lastMqaDataSent, mediaType, }: {
+    videoSenderStream: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    mediaType: any;
+}) => void;

package/dist/webinar/collection.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
+ */
+declare class WebinarCollection {
+    webinarInfo: any;
+    namespace: string;
+    mainIndex: string;
+    constructor();
+    set(id: any, info: any): void;
+    /**
+     * @param {String} id
+     * @returns {Member}
+     */
+    get(id: string): any;
+}
+export default WebinarCollection;

package/dist/webinar/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @class Webinar
+ */
+declare const Webinar: any;
+export default Webinar;