@webex/plugin-meetings 3.3.1-next.2 → 3.3.1-next.21

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

@@ -1,8 +1,10 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
+import { Defer } from '@webex/common';
 import ReachabilityRequest from './request';
 import { ClusterReachability, ClusterReachabilityResult } from './clusterReachability';
+import EventsScope from '../common/events/events-scope';
 export type ReachabilityMetrics = {
     reachability_public_udp_success: number;
     reachability_public_udp_failed: number;
@@ -40,13 +42,37 @@ export type ReachabilityResults = Record<string, ClusterReachabilityResult & {
  * @class Reachability
  * @export
  */
-export default class Reachability {
+export default class Reachability extends EventsScope {
     namespace: string;
     webex: object;
     reachabilityRequest: ReachabilityRequest;
     clusterReachability: {
         [key: string]: ClusterReachability;
     };
+    reachabilityDefer?: Defer;
+    vmnTimer?: ReturnType<typeof setTimeout>;
+    publicCloudTimer?: ReturnType<typeof setTimeout>;
+    overallTimer?: ReturnType<typeof setTimeout>;
+    expectedResultsCount: {
+        videoMesh: {
+            udp: number;
+        };
+        public: {
+            udp: number;
+            tcp: number;
+            xtls: number;
+        };
+    };
+    resultsCount: {
+        videoMesh: {
+            udp: number;
+        };
+        public: {
+            udp: number;
+            tcp: number;
+            xtls: number;
+        };
+    };
     /**
      * Creates an instance of Reachability.
      * @param {object} webex
@@ -111,10 +137,75 @@ export default class Reachability {
      * @memberof Reachability
      */
     private logUnreachableClusters;
+    /**
+     * Returns true if we've obtained all the reachability results for all the public clusters
+     * In other words, it means that all public clusters are reachable over each protocol,
+     * because we only get a "result" if we managed to reach a cluster
+     *
+     * @returns {boolean}
+     */
+    private areAllPublicClusterResultsReady;
+    /**
+     * Returns true if we've obtained all the reachability results for all the clusters
+     *
+     * @returns {boolean}
+     */
+    private areAllResultsReady;
+    /**
+     * Resolves the promise returned by gatherReachability() method
+     * @returns {void}
+     */
+    private resolveReachabilityPromise;
+    /**
+     * Aborts all cluster reachability checks that are in progress
+     *
+     * @returns {void}
+     */
+    private abortClusterReachability;
+    /**
+     * Helper function for calculating min/max/average values of latency
+     *
+     * @param {Array<any>} results
+     * @param {string} protocol
+     * @param {boolean} isVideoMesh
+     * @returns {{min:number, max: number, average: number}}
+     */
+    protected getStatistics(results: Array<ClusterReachabilityResult & {
+        isVideoMesh: boolean;
+    }>, protocol: 'udp' | 'tcp' | 'xtls', isVideoMesh: boolean): {
+        min: number;
+        max: number;
+        average: number;
+    };
+    /**
+     * Sends a metric with all the statistics about how long reachability took
+     *
+     * @returns {void}
+     */
+    protected sendMetric(): Promise<void>;
+    /**
+     * Starts all the timers used for various timeouts
+     *
+     * @returns {void}
+     */
+    private startTimers;
+    /**
+     * Stores given reachability results in local storage
+     *
+     * @param {ReachabilityResults} results
+     * @returns {Promise<void>}
+     */
+    private storeResults;
+    /**
+     * Resets all the internal counters that keep track of the results
+     *
+     * @returns {void}
+     */
+    private resetResultCounters;
     /**
      * Performs reachability checks for all clusters
      * @param {ClusterList} clusterList
-     * @returns {Promise<ReachabilityResults>} reachability check results
+     * @returns {Promise<void>} promise that's resolved as soon as the checks are started
      */
     private performReachabilityChecks;
 }

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

@@ -36,17 +36,26 @@ export declare class StatsAnalyzer extends EventsScope {
     statsStarted: any;
     successfulCandidatePair: any;
     localIpAddress: string;
+    shareVideoEncoderImplementation?: string;
     receiveSlotCallback: ReceiveSlotCallback;
+    isMultistream: boolean;
     /**
      * 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);
+     * @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
+     * @param {boolean | undefined} isMultistream - Param indicating if the media connection is multistream or not
+     */
+    constructor({ config, receiveSlotCallback, networkQualityMonitor, statsResults, isMultistream, }: {
+        config: any;
+        receiveSlotCallback: ReceiveSlotCallback;
+        networkQualityMonitor: any;
+        statsResults?: any;
+        isMultistream?: boolean;
+    });
     /**
      * Resets cumulative stats arrays.
      *

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

@@ -1,8 +1,9 @@
-export declare const getAudioReceiverMqa: ({ audioReceiver, statsResults, lastMqaDataSent, baseMediaType, }: {
+export declare const getAudioReceiverMqa: ({ audioReceiver, statsResults, lastMqaDataSent, baseMediaType, isMultistream, }: {
     audioReceiver: any;
     statsResults: any;
     lastMqaDataSent: any;
     baseMediaType: any;
+    isMultistream: any;
 }) => void;
 export declare const getAudioReceiverStreamMqa: ({ audioReceiverStream, statsResults, lastMqaDataSent, mediaType, }: {
     audioReceiverStream: any;
@@ -10,11 +11,12 @@ export declare const getAudioReceiverStreamMqa: ({ audioReceiverStream, statsRes
     lastMqaDataSent: any;
     mediaType: any;
 }) => void;
-export declare const getAudioSenderMqa: ({ audioSender, statsResults, lastMqaDataSent, baseMediaType }: {
+export declare const getAudioSenderMqa: ({ audioSender, statsResults, lastMqaDataSent, baseMediaType, isMultistream, }: {
     audioSender: any;
     statsResults: any;
     lastMqaDataSent: any;
     baseMediaType: any;
+    isMultistream: any;
 }) => void;
 export declare const getAudioSenderStreamMqa: ({ audioSenderStream, statsResults, lastMqaDataSent, mediaType, }: {
     audioSenderStream: any;
@@ -22,11 +24,12 @@ export declare const getAudioSenderStreamMqa: ({ audioSenderStream, statsResults
     lastMqaDataSent: any;
     mediaType: any;
 }) => void;
-export declare const getVideoReceiverMqa: ({ videoReceiver, statsResults, lastMqaDataSent, baseMediaType, }: {
+export declare const getVideoReceiverMqa: ({ videoReceiver, statsResults, lastMqaDataSent, baseMediaType, isMultistream, }: {
     videoReceiver: any;
     statsResults: any;
     lastMqaDataSent: any;
     baseMediaType: any;
+    isMultistream: any;
 }) => void;
 export declare const getVideoReceiverStreamMqa: ({ videoReceiverStream, statsResults, lastMqaDataSent, mediaType, }: {
     videoReceiverStream: any;
@@ -34,11 +37,12 @@ export declare const getVideoReceiverStreamMqa: ({ videoReceiverStream, statsRes
     lastMqaDataSent: any;
     mediaType: any;
 }) => void;
-export declare const getVideoSenderMqa: ({ videoSender, statsResults, lastMqaDataSent, baseMediaType }: {
+export declare const getVideoSenderMqa: ({ videoSender, statsResults, lastMqaDataSent, baseMediaType, isMultistream, }: {
     videoSender: any;
     statsResults: any;
     lastMqaDataSent: any;
     baseMediaType: any;
+    isMultistream: any;
 }) => void;
 export declare const getVideoSenderStreamMqa: ({ videoSenderStream, statsResults, lastMqaDataSent, mediaType, }: {
     videoSenderStream: any;
@@ -46,3 +50,12 @@ export declare const getVideoSenderStreamMqa: ({ videoSenderStream, statsResults
     lastMqaDataSent: any;
     mediaType: any;
 }) => void;
+/**
+ * Checks if stream stats should be updated based on request status and elapsed time.
+ *
+ * @param {Object} statsResults - Stats results object.
+ * @param {string} mediaType - Media type (e.g., 'audio', 'video').
+ * @param {string} direction - Stats direction (e.g., 'send', 'receive').
+ * @returns {boolean} Whether stats should be updated.
+ */
+export declare const isStreamRequested: (statsResults: any, mediaType: string, direction: string) => boolean;

package/dist/webinar/index.js

@@ -62,7 +62,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
   updateCanManageWebcast: function updateCanManageWebcast(canManageWebcast) {
     this.set('canManageWebcast', canManageWebcast);
   },
-  version: "3.3.1-next.2"
+  version: "3.3.1-next.21"
 });
 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.3.1-next.2",
-    "@webex/plugin-rooms": "3.3.1-next.2",
-    "@webex/test-helper-chai": "3.3.1-next.1",
-    "@webex/test-helper-mocha": "3.3.1-next.1",
-    "@webex/test-helper-mock-webex": "3.3.1-next.1",
-    "@webex/test-helper-retry": "3.3.1-next.1",
-    "@webex/test-helper-test-users": "3.3.1-next.1",
+    "@webex/plugin-meetings": "3.3.1-next.21",
+    "@webex/plugin-rooms": "3.3.1-next.5",
+    "@webex/test-helper-chai": "3.3.1-next.4",
+    "@webex/test-helper-mocha": "3.3.1-next.4",
+    "@webex/test-helper-mock-webex": "3.3.1-next.4",
+    "@webex/test-helper-retry": "3.3.1-next.4",
+    "@webex/test-helper-test-users": "3.3.1-next.4",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "eslint": "^8.24.0",
@@ -61,20 +61,21 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.3.1-next.1",
-    "@webex/internal-media-core": "2.5.1",
-    "@webex/internal-plugin-conversation": "3.3.1-next.2",
-    "@webex/internal-plugin-device": "3.3.1-next.1",
-    "@webex/internal-plugin-llm": "3.3.1-next.2",
-    "@webex/internal-plugin-mercury": "3.3.1-next.2",
-    "@webex/internal-plugin-metrics": "3.3.1-next.1",
-    "@webex/internal-plugin-support": "3.3.1-next.2",
-    "@webex/internal-plugin-user": "3.3.1-next.1",
-    "@webex/internal-plugin-voicea": "3.3.1-next.2",
-    "@webex/media-helpers": "3.3.1-next.1",
-    "@webex/plugin-people": "3.3.1-next.2",
-    "@webex/plugin-rooms": "3.3.1-next.2",
-    "@webex/webex-core": "3.3.1-next.1",
+    "@webex/common": "3.3.1-next.4",
+    "@webex/internal-media-core": "2.7.1",
+    "@webex/internal-plugin-conversation": "3.3.1-next.5",
+    "@webex/internal-plugin-device": "3.3.1-next.4",
+    "@webex/internal-plugin-llm": "3.3.1-next.6",
+    "@webex/internal-plugin-mercury": "3.3.1-next.5",
+    "@webex/internal-plugin-metrics": "3.3.1-next.4",
+    "@webex/internal-plugin-support": "3.3.1-next.5",
+    "@webex/internal-plugin-user": "3.3.1-next.4",
+    "@webex/internal-plugin-voicea": "3.3.1-next.21",
+    "@webex/media-helpers": "3.3.1-next.7",
+    "@webex/plugin-people": "3.3.1-next.5",
+    "@webex/plugin-rooms": "3.3.1-next.5",
+    "@webex/web-capabilities": "^1.3.0",
+    "@webex/webex-core": "3.3.1-next.4",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
@@ -91,5 +92,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.3.1-next.2"
+  "version": "3.3.1-next.21"
 }

package/src/breakouts/index.ts

@@ -148,7 +148,6 @@ const Breakouts = WebexPlugin.extend({
       this.triggerReturnToMainEvent(breakout);
     });
     this.listenToCurrentSessionTypeChange();
-    this.listenToBroadcastMessages();
     this.listenToBreakoutRosters();
     this.listenToBreakoutHelp();
     // @ts-ignore
@@ -161,6 +160,7 @@ const Breakouts = WebexPlugin.extend({
    */
   cleanUp() {
     this.stopListening();
+    this.hasSubscribedToMessage = undefined;
   },
 
   /**
@@ -170,6 +170,7 @@ const Breakouts = WebexPlugin.extend({
    */
   locusUrlUpdate(locusUrl) {
     this.set('locusUrl', locusUrl);
+    this.listenToBroadcastMessages();
     const {isInMainSession, mainLocusUrl} = this;
     if (isInMainSession || !mainLocusUrl) {
       this.set('mainLocusUrl', locusUrl);
@@ -255,6 +256,10 @@ const Breakouts = WebexPlugin.extend({
    * @returns {void}
    */
   listenToBroadcastMessages() {
+    if (!this.webex.internal.llm.isConnected() || this.hasSubscribedToMessage) {
+      return;
+    }
+
     this.listenTo(this.webex.internal.llm, 'event:breakout.message', (event) => {
       const {
         data: {senderUserId, sentTime, message},
@@ -270,6 +275,7 @@ const Breakouts = WebexPlugin.extend({
         sessionId: this.currentBreakoutSession.sessionId,
       });
     });
+    this.hasSubscribedToMessage = true;
   },
 
   /**

package/src/media/MediaConnectionAwaiter.ts

@@ -15,8 +15,10 @@ export default class MediaConnectionAwaiter {
   private timer: any;
   private defer: Defer;
   private retried: boolean;
+  private iceConnected: boolean;
   private onTimeoutCallback: () => void;
-  private connectionStateCallback: () => void;
+  private peerConnectionStateCallback: () => void;
+  private iceConnectionStateCallback: () => void;
   private iceGatheringStateCallback: () => void;
 
   /**
@@ -26,9 +28,11 @@ export default class MediaConnectionAwaiter {
     this.webrtcMediaConnection = webrtcMediaConnection;
     this.defer = new Defer();
     this.retried = false;
+    this.iceConnected = false;
     this.onTimeoutCallback = this.onTimeout.bind(this);
-    this.connectionStateCallback = this.connectionStateListenerCallback.bind(this);
-    this.iceGatheringStateCallback = this.iceGatheringStateListenerCallback.bind(this);
+    this.peerConnectionStateCallback = this.peerConnectionStateHandler.bind(this);
+    this.iceConnectionStateCallback = this.iceConnectionStateHandler.bind(this);
+    this.iceGatheringStateCallback = this.iceGatheringStateHandler.bind(this);
   }
 
   /**
@@ -59,17 +63,24 @@ export default class MediaConnectionAwaiter {
       Event.ICE_GATHERING_STATE_CHANGED,
       this.iceGatheringStateCallback
     );
-    this.webrtcMediaConnection.off(Event.CONNECTION_STATE_CHANGED, this.connectionStateCallback);
+    this.webrtcMediaConnection.off(
+      Event.PEER_CONNECTION_STATE_CHANGED,
+      this.peerConnectionStateCallback
+    );
+    this.webrtcMediaConnection.off(
+      Event.ICE_CONNECTION_STATE_CHANGED,
+      this.iceConnectionStateCallback
+    );
   }
 
   /**
-   * Listener for connection state change.
+   * On connection state change.
    *
    * @returns {void}
    */
-  connectionStateListenerCallback(): void {
+  connectionStateChange(): void {
     LoggerProxy.logger.log(
-      `Media:MediaConnectionAwaiter#connectionStateListenerCallback --> connection state: ${this.webrtcMediaConnection.getConnectionState()}`
+      `Media:MediaConnectionAwaiter#connectionStateChange --> connection state: ${this.webrtcMediaConnection.getConnectionState()}`
     );
 
     if (!this.isConnected()) {
@@ -83,16 +94,50 @@ export default class MediaConnectionAwaiter {
     this.defer.resolve();
   }
 
+  /**
+   * Listener for peer connection state change.
+   *
+   * @returns {void}
+   */
+  peerConnectionStateHandler(): void {
+    const peerConnectionState = this.webrtcMediaConnection.getPeerConnectionState();
+
+    LoggerProxy.logger.log(
+      `Media:MediaConnectionAwaiter#peerConnectionStateHandler --> Peer connection state change -> ${peerConnectionState}`
+    );
+
+    this.connectionStateChange();
+  }
+
+  /**
+   * Listener for ICE connection state change.
+   *
+   * @returns {void}
+   */
+  iceConnectionStateHandler(): void {
+    const iceConnectionState = this.webrtcMediaConnection.getIceConnectionState();
+
+    LoggerProxy.logger.log(
+      `Media:MediaConnectionAwaiter#iceConnectionStateHandler --> ICE connection state change -> ${iceConnectionState}`
+    );
+
+    if (iceConnectionState === 'connected' && !this.iceConnected) {
+      this.iceConnected = true;
+    }
+
+    this.connectionStateChange();
+  }
+
   /**
    * Listener for ICE gathering state change.
    *
    * @returns {void}
    */
-  iceGatheringStateListenerCallback(): void {
+  iceGatheringStateHandler(): void {
     const iceGatheringState = this.webrtcMediaConnection.getIceGatheringState();
 
     LoggerProxy.logger.log(
-      `Media:MediaConnectionAwaiter#iceGatheringStateListenerCallback --> ICE gathering state change -> ${iceGatheringState}`
+      `Media:MediaConnectionAwaiter#iceGatheringStateHandler --> ICE gathering state change -> ${iceGatheringState}`
     );
 
     if (!this.isIceGatheringCompleted()) {
@@ -147,7 +192,9 @@ export default class MediaConnectionAwaiter {
 
     this.clearCallbacks();
 
-    this.defer.reject();
+    this.defer.reject({
+      iceConnected: this.iceConnected,
+    });
   }
 
   /**
@@ -160,7 +207,15 @@ export default class MediaConnectionAwaiter {
       return Promise.resolve();
     }
 
-    this.webrtcMediaConnection.on(Event.CONNECTION_STATE_CHANGED, this.connectionStateCallback);
+    this.webrtcMediaConnection.on(
+      Event.PEER_CONNECTION_STATE_CHANGED,
+      this.peerConnectionStateCallback
+    );
+
+    this.webrtcMediaConnection.on(
+      Event.ICE_CONNECTION_STATE_CHANGED,
+      this.iceConnectionStateCallback
+    );
 
     this.webrtcMediaConnection.on(
       Event.ICE_GATHERING_STATE_CHANGED,

package/src/mediaQualityMetrics/config.ts

@@ -4,10 +4,21 @@ export const emptyMqaInterval = {
   intervalMetadata: {
     peerReflexiveIP: '0.0.0.0',
     peripherals: [],
+    cpuInfo: {
+      numberOfCores: 1, // default value from spec if CpuInfo.getNumLogicalCores cannot be determined
+      description: 'NA',
+      architecture: 'unknown',
+    },
     processAverageCPU: 0,
     processMaximumCPU: 0,
     systemAverageCPU: 0,
     systemMaximumCPU: 0,
+    screenWidth: 0,
+    screenHeight: 0,
+    screenResolution: 0,
+    appWindowWidth: 0,
+    appWindowHeight: 0,
+    appWindowSize: 0,
   },
   networkType: '',
   intervalNumber: 0,
@@ -126,7 +137,7 @@ export const emptyVideoReceive = {
       mariRtxEnabled: false,
       mariQosEnabled: false,
       mariLiteEnabled: false,
-      multistreamEnabled: true, // Not avaliable
+      multistreamEnabled: false,
     },
     dtlsBitrate: 0, // Not avaliable
     dtlsPackets: 0, // Not avaliable
@@ -170,7 +181,7 @@ export const emptyVideoReceiveStream = {
     ssci: 0, // Not avaliable
   },
   h264CodecProfile: 'BP',
-  isActiveSpeaker: true,
+  isActiveSpeaker: false,
   optimalFrameSize: 0, // Not avaliable
   receivedFrameSize: 0,
   receivedHeight: 0,
@@ -193,7 +204,7 @@ export const emptyVideoTransmit = {
       mariRtxEnabled: false,
       mariQosEnabled: false,
       mariLiteEnabled: false,
-      multistreamEnabled: false, // Not avaliable
+      multistreamEnabled: false,
     },
     dtlsBitrate: 0, // Not avaliable
     dtlsPackets: 0, // Not avaliable

package/src/meeting/connectionStateHandler.ts

@@ -0,0 +1,65 @@
+import {Event, ConnectionState} from '@webex/internal-media-core';
+import EventsScope from '../common/events/events-scope';
+import {Enum} from '../constants';
+
+export const ConnectionStateEvent = {
+  stateChanged: 'connectionState:changed',
+} as const;
+
+export type ConnectionStateEvent = Enum<typeof ConnectionStateEvent>;
+
+export interface ConnectionStateChangedEvent {
+  /**
+   * Current overall connection state
+   */
+  state: ConnectionState;
+}
+
+/**
+ * @class ConnectionStateHandler
+ */
+export class ConnectionStateHandler extends EventsScope {
+  private webrtcMediaConnection: any;
+
+  private mediaConnectionState: ConnectionState;
+
+  /**
+   * @param {WebRTCMeeting} webrtcMediaConnection
+   */
+  constructor(webrtcMediaConnection) {
+    super();
+
+    this.webrtcMediaConnection = webrtcMediaConnection;
+
+    this.webrtcMediaConnection.on(
+      Event.PEER_CONNECTION_STATE_CHANGED,
+      this.handleConnectionStateChange.bind(this)
+    );
+
+    this.webrtcMediaConnection.on(
+      Event.ICE_CONNECTION_STATE_CHANGED,
+      this.handleConnectionStateChange.bind(this)
+    );
+  }
+
+  /**
+   * Handler for connection state change.
+   *
+   * @returns {void}
+   */
+  private handleConnectionStateChange(): void {
+    const newConnectionState = this.webrtcMediaConnection.getConnectionState();
+
+    if (newConnectionState !== this.mediaConnectionState) {
+      this.mediaConnectionState = newConnectionState;
+      this.emit(
+        {
+          file: 'connectionStateHandler',
+          function: 'handleConnectionStateChange',
+        },
+        ConnectionStateEvent.stateChanged,
+        {state: this.mediaConnectionState}
+      );
+    }
+  }
+}