@webex/plugin-meetings 3.7.0-wxcc.1 → 3.8.0

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;

package/dist/webinar/index.js

@@ -458,7 +458,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
       }, _callee7);
     }))();
   },
-  version: "3.7.0-wxcc.1"
+  version: "3.8.0"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -43,13 +43,13 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/plugin-meetings": "3.7.0-wxcc.1",
-    "@webex/plugin-rooms": "3.7.0-wxcc.1",
-    "@webex/test-helper-chai": "3.7.0-wxcc.1",
-    "@webex/test-helper-mocha": "3.7.0-wxcc.1",
-    "@webex/test-helper-mock-webex": "3.7.0-wxcc.1",
-    "@webex/test-helper-retry": "3.7.0-wxcc.1",
-    "@webex/test-helper-test-users": "3.7.0-wxcc.1",
+    "@webex/plugin-meetings": "3.8.0",
+    "@webex/plugin-rooms": "3.8.0",
+    "@webex/test-helper-chai": "3.8.0",
+    "@webex/test-helper-mocha": "3.8.0",
+    "@webex/test-helper-mock-webex": "3.8.0",
+    "@webex/test-helper-retry": "3.8.0",
+    "@webex/test-helper-test-users": "3.8.0",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "eslint": "^8.24.0",
@@ -61,22 +61,22 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.7.0-wxcc.1",
-    "@webex/event-dictionary-ts": "^1.0.1643",
-    "@webex/internal-media-core": "2.14.2",
-    "@webex/internal-plugin-conversation": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-device": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-llm": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-mercury": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-metrics": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-support": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-user": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-voicea": "3.7.0-wxcc.1",
-    "@webex/media-helpers": "3.7.0-wxcc.1",
-    "@webex/plugin-people": "3.7.0-wxcc.1",
-    "@webex/plugin-rooms": "3.7.0-wxcc.1",
+    "@webex/common": "3.8.0",
+    "@webex/event-dictionary-ts": "^1.0.1688",
+    "@webex/internal-media-core": "2.14.4",
+    "@webex/internal-plugin-conversation": "3.8.0",
+    "@webex/internal-plugin-device": "3.8.0",
+    "@webex/internal-plugin-llm": "3.8.0",
+    "@webex/internal-plugin-mercury": "3.8.0",
+    "@webex/internal-plugin-metrics": "3.8.0",
+    "@webex/internal-plugin-support": "3.8.0",
+    "@webex/internal-plugin-user": "3.8.0",
+    "@webex/internal-plugin-voicea": "3.8.0",
+    "@webex/media-helpers": "3.8.0",
+    "@webex/plugin-people": "3.8.0",
+    "@webex/plugin-rooms": "3.8.0",
     "@webex/web-capabilities": "^1.4.0",
-    "@webex/webex-core": "3.7.0-wxcc.1",
+    "@webex/webex-core": "3.8.0",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
@@ -92,5 +92,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.7.0-wxcc.1"
+  "version": "3.8.0"
 }

package/src/constants.ts

@@ -202,7 +202,7 @@ export const RETRY_TIMEOUT = 3000;
 export const ICE_AND_DTLS_CONNECTION_TIMEOUT = 20000;
 export const ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT = 35000;
 export const WEBINAR_ERROR_WEBCAST = [403026];
-export const WEBINAR_ERROR_REGISTRATIONID = [403037, 403137];
+export const WEBINAR_ERROR_REGISTRATION_ID = [403037, 403137];
 export const JOIN_BEFORE_HOST = 403003;
 
 // ******************** REGEX **********************
@@ -1331,14 +1331,22 @@ export const PASSWORD_STATUS = {
   VERIFIED: 'VERIFIED', // client has already provided the password and it has been verified, client can proceed to call join()
 };
 
+export const REGISTRATION_ID_STATUS = {
+  NOT_REQUIRED: 'NOT_REQUIRED', // registrationId is not required to join the meeting
+  REQUIRED: 'REQUIRED', // client needs to provide the registrationId by calling verifyRegistrationId() before calling join()
+  UNKNOWN: 'UNKNOWN', // we are waiting for information from the backend if registrationId is required or not
+  VERIFIED: 'VERIFIED', // client has already provided the registrationId and it has been verified, client can proceed to call join()
+};
+
 export const MEETING_INFO_FAILURE_REASON = {
   NONE: 'NONE', // meeting info was retrieved succesfully
   WRONG_PASSWORD: 'WRONG_PASSWORD', // meeting requires password and no password or wrong one was provided
   WRONG_CAPTCHA: 'WRONG_CAPTCHA', // wbxappapi requires a captcha code or a wrong captcha code was provided
+  WRONG_REGISTRATION_ID: 'WRONG_REGISTRATION_ID', // meeting requires registrationId and no registrationId or wrong one was provided
   POLICY: 'POLICY', // meeting info request violates some meeting policy
   WEBINAR_REGISTRATION: 'WEBINAR_REGISTRATION', // webinar need registration
   NEED_JOIN_WITH_WEBCAST: 'NEED_JOIN_WITH_WEBCAST', // webinar need using webcast join
-  WEBINAR_NEED_REGISTRATIONID: 'WEBINAR_NEED_REGISTRATIONID', // webinar need registrationID
+  WEBINAR_NEED_REGISTRATION_ID: 'WEBINAR_NEED_REGISTRATION_ID', // webinar need registrationID
   NOT_REACH_JBH: 'NOT_REACH_JBH', // Meeting is not allow to access since not reach JBH (join before host) time
   JOIN_FORBIDDEN: 'JOIN_FORBIDDEN', // meeting is not allow join
   OTHER: 'OTHER', // any other error (network, etc)

package/src/locus-info/selfUtils.ts

@@ -441,6 +441,11 @@ SelfUtils.mutedByOthersChanged = (oldSelf, changedSelf) => {
     return false;
   }
 
+  // there is no need to trigger user update if no one muted user
+  if (changedSelf.selfIdentity === changedSelf.modifiedBy) {
+    return false;
+  }
+
   return (
     changedSelf.remoteMuted !== null &&
     (oldSelf.remoteMuted !== changedSelf.remoteMuted ||

package/src/media/MediaConnectionAwaiter.ts

@@ -111,6 +111,8 @@ export default class MediaConnectionAwaiter {
 
     this.clearCallbacks();
 
+    LoggerProxy.logger.warn('Media:MediaConnectionAwaiter#connectionStateChange --> Resolving');
+
     this.defer.resolve();
   }
 

package/src/media/properties.ts

@@ -287,24 +287,45 @@ export default class MediaProperties {
     selectedCandidatePairChanges: number;
     numTransports: number;
   }> {
-    const allStatsReports = [];
-
     try {
-      const statsResult = await this.webrtcMediaConnection.getStats();
-      statsResult.forEach((report) => allStatsReports.push(report));
+      const allStatsReports = [];
+
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error('timed out'));
+        }, 1000);
+
+        this.webrtcMediaConnection
+          .getStats()
+          .then((statsResult) => {
+            clearTimeout(timeout);
+            statsResult.forEach((report) => allStatsReports.push(report));
+            resolve(allStatsReports);
+          })
+          .catch((error) => {
+            clearTimeout(timeout);
+            reject(error);
+          });
+      });
+
+      const connectionType = this.getConnectionType(allStatsReports);
+      const {selectedCandidatePairChanges, numTransports} = this.getTransportInfo(allStatsReports);
+
+      return {
+        connectionType,
+        selectedCandidatePairChanges,
+        numTransports,
+      };
     } catch (error) {
       LoggerProxy.logger.warn(
         `Media:properties#getCurrentConnectionInfo --> getStats() failed: ${error}`
       );
-    }
-
-    const connectionType = this.getConnectionType(allStatsReports);
-    const {selectedCandidatePairChanges, numTransports} = this.getTransportInfo(allStatsReports);
 
-    return {
-      connectionType,
-      selectedCandidatePairChanges,
-      numTransports,
-    };
+      return {
+        connectionType: 'unknown',
+        selectedCandidatePairChanges: -1,
+        numTransports: 0,
+      };
+    }
   }
 }

package/src/meeting/brbState.ts

@@ -0,0 +1,169 @@
+import {MediaType} from '@webex/internal-media-core';
+import LoggerProxy from '../common/logs/logger-proxy';
+import type Meeting from '.';
+import SendSlotManager from '../multistream/sendSlotManager';
+
+export const createBrbState = (meeting: Meeting, enabled: boolean) => {
+  LoggerProxy.logger.info(
+    `Meeting:brbState#createBrbState: creating BrbState for meeting id ${meeting?.id}`
+  );
+
+  const brbState = new BrbState(meeting, enabled);
+
+  return brbState;
+};
+
+/** The purpose of this class is to manage the local and remote brb state
+ * and make sure that the server state always matches the last requested state by the client.
+ */
+export class BrbState {
+  state: {
+    client: {
+      enabled: boolean;
+    };
+    server: {
+      enabled: boolean;
+    };
+    syncToServerInProgress: boolean;
+  };
+
+  meeting: Meeting;
+
+  /**
+   * Constructor
+   *
+   * @param {Meeting} meeting - the meeting object
+   * @param {boolean} enabled - whether the client audio/video is enabled at all
+   */
+  constructor(meeting: Meeting, enabled: boolean) {
+    this.meeting = meeting;
+    this.state = {
+      client: {
+        enabled,
+      },
+      server: {
+        enabled: false,
+      },
+      syncToServerInProgress: false,
+    };
+  }
+
+  /**
+   * Enables/disables brb
+   *
+   * @param {boolean} enabled
+   * @param {SendSlotManager} sendSlotManager
+   * @returns {Promise}
+   */
+  public enable(enabled: boolean, sendSlotManager: SendSlotManager) {
+    this.state.client.enabled = enabled;
+
+    return this.applyClientStateToServer(sendSlotManager);
+  }
+
+  /**
+   * Updates the server local and remote brb values so that they match the current client desired state.
+   *
+   * @param {SendSlotManager} sendSlotManager
+   * @returns {Promise}
+   */
+  private applyClientStateToServer(sendSlotManager: SendSlotManager) {
+    if (this.state.syncToServerInProgress) {
+      LoggerProxy.logger.info(
+        `Meeting:brbState#applyClientStateToServer: request to server in progress, we need to wait for it to complete`
+      );
+
+      return Promise.resolve();
+    }
+
+    const remoteBrbRequiresSync = this.state.client.enabled !== this.state.server.enabled;
+
+    LoggerProxy.logger.info(
+      `Meeting:brbState#applyClientStateToServer: remoteBrbRequiresSync: ${remoteBrbRequiresSync}`
+    );
+
+    if (!remoteBrbRequiresSync) {
+      LoggerProxy.logger.info(
+        `Meeting:brbState#applyClientStateToServer: client state already matching server state, nothing to do`
+      );
+
+      return Promise.resolve();
+    }
+
+    this.state.syncToServerInProgress = true;
+
+    return this.sendLocalBrbStateToServer(sendSlotManager)
+      .then(() => {
+        this.state.syncToServerInProgress = false;
+        LoggerProxy.logger.info(
+          `Meeting:brbState#applyClientStateToServer: sync with server completed`
+        );
+
+        // need to check if a new sync is required, because this.state.client may have changed while we were doing the current sync
+        this.applyClientStateToServer(sendSlotManager);
+      })
+      .catch((e) => {
+        this.state.syncToServerInProgress = false;
+        LoggerProxy.logger.warn(`Meeting:brbState#applyClientStateToServer: error: ${e}`);
+      });
+  }
+
+  /**
+   * Send the local brb state to the server
+   *
+   * @param {SendSlotManager} sendSlotManager
+   * @returns {Promise}
+   */
+  private async sendLocalBrbStateToServer(sendSlotManager: SendSlotManager) {
+    const {enabled} = this.state.client;
+
+    if (!this.meeting.isMultistream) {
+      const errorMessage = 'Meeting:brbState#sendLocalBrbStateToServer: Not a multistream meeting';
+      const error = new Error(errorMessage);
+
+      LoggerProxy.logger.error(error);
+
+      return Promise.reject(error);
+    }
+
+    if (!this.meeting.mediaProperties.webrtcMediaConnection) {
+      const errorMessage =
+        'Meeting:brbState#sendLocalBrbStateToServer: WebRTC media connection is not defined';
+      const error = new Error(errorMessage);
+
+      LoggerProxy.logger.error(error);
+
+      return Promise.reject(error);
+    }
+
+    // this logic should be applied only to multistream meetings
+    return this.meeting.meetingRequest
+      .setBrb({
+        enabled,
+        locusUrl: this.meeting.locusUrl,
+        deviceUrl: this.meeting.deviceUrl,
+        selfId: this.meeting.selfId,
+      })
+      .then(() => {
+        sendSlotManager.setSourceStateOverride(MediaType.VideoMain, enabled ? 'away' : null);
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error('Meeting:brbState#sendLocalBrbStateToServer: Error ', error);
+
+        return Promise.reject(error);
+      });
+  }
+
+  /**
+   * This method should be called whenever the server brb state is changed
+   *
+   * @param {Boolean} [enabled] true if user has brb enabled, false otherwise
+   * @returns {undefined}
+   */
+  public handleServerBrbUpdate(enabled?: boolean) {
+    LoggerProxy.logger.info(
+      `Meeting:brbState#handleServerBrbUpdate: updating server brb to (${enabled})`
+    );
+    this.state.server.enabled = !!enabled;
+  }
+}