@webex/plugin-meetings 2.34.0 → 2.35.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "2.34.0",
+  "version": "2.35.1",
   "description": "",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "contributors": [
@@ -13,7 +13,11 @@
   ],
   "main": "dist/index.js",
   "devMain": "src/index.js",
-  "repository": "https://github.com/webex/webex-js-sdk/tree/master/packages/@webex/plugin-meetings",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/webex/webex-js-sdk.git",
+    "directory": "packages/@webex/plugin-meetings"
+  },
   "engines": {
     "node": ">=14"
   },
@@ -24,30 +28,30 @@
     ]
   },
   "devDependencies": {
-    "@webex/plugin-meetings": "2.34.0",
-    "@webex/test-helper-chai": "2.34.0",
-    "@webex/test-helper-mocha": "2.34.0",
-    "@webex/test-helper-mock-webex": "2.34.0",
-    "@webex/test-helper-retry": "2.34.0",
-    "@webex/test-helper-test-users": "2.34.0",
+    "@webex/plugin-meetings": "2.35.1",
+    "@webex/test-helper-chai": "2.35.1",
+    "@webex/test-helper-mocha": "2.35.1",
+    "@webex/test-helper-mock-webex": "2.35.1",
+    "@webex/test-helper-retry": "2.35.1",
+    "@webex/test-helper-test-users": "2.35.1",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "jsdom-global": "3.0.2",
     "sinon": "^9.2.4"
   },
   "dependencies": {
-    "@webex/common": "2.34.0",
+    "@webex/common": "2.35.1",
     "@webex/internal-media-core": "^0.0.7-beta",
-    "@webex/internal-plugin-conversation": "2.34.0",
-    "@webex/internal-plugin-device": "2.34.0",
-    "@webex/internal-plugin-mercury": "2.34.0",
-    "@webex/internal-plugin-metrics": "2.34.0",
-    "@webex/internal-plugin-support": "2.34.0",
-    "@webex/internal-plugin-user": "2.34.0",
-    "@webex/plugin-people": "2.34.0",
-    "@webex/plugin-rooms": "2.34.0",
+    "@webex/internal-plugin-conversation": "2.35.1",
+    "@webex/internal-plugin-device": "2.35.1",
+    "@webex/internal-plugin-mercury": "2.35.1",
+    "@webex/internal-plugin-metrics": "2.35.1",
+    "@webex/internal-plugin-support": "2.35.1",
+    "@webex/internal-plugin-user": "2.35.1",
+    "@webex/plugin-people": "2.35.1",
+    "@webex/plugin-rooms": "2.35.1",
     "@webex/ts-sdp": "^1.0.1",
-    "@webex/webex-core": "2.34.0",
+    "@webex/webex-core": "2.35.1",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
     "dotenv": "^4.0.0",

package/src/constants.ts

@@ -972,7 +972,7 @@ export const QUALITY_LEVELS = {
 };
 
 
-export const AVALIABLE_RESOLUTIONS = {
+export const AVAILABLE_RESOLUTIONS = {
   '360p': {
     video: {
       width: {
@@ -1024,13 +1024,13 @@ export const AVALIABLE_RESOLUTIONS = {
 };
 
 export const VIDEO_RESOLUTIONS = {
-  [QUALITY_LEVELS.LOW]: AVALIABLE_RESOLUTIONS['480p'],
-  [QUALITY_LEVELS.MEDIUM]: AVALIABLE_RESOLUTIONS['720p'],
-  [QUALITY_LEVELS.HIGH]: AVALIABLE_RESOLUTIONS['1080p'],
-  [QUALITY_LEVELS['360p']]: AVALIABLE_RESOLUTIONS['360p'],
-  [QUALITY_LEVELS['480p']]: AVALIABLE_RESOLUTIONS['480p'],
-  [QUALITY_LEVELS['720p']]: AVALIABLE_RESOLUTIONS['720p'],
-  [QUALITY_LEVELS['1080p']]: AVALIABLE_RESOLUTIONS['1080p'],
+  [QUALITY_LEVELS.LOW]: AVAILABLE_RESOLUTIONS['480p'],
+  [QUALITY_LEVELS.MEDIUM]: AVAILABLE_RESOLUTIONS['720p'],
+  [QUALITY_LEVELS.HIGH]: AVAILABLE_RESOLUTIONS['1080p'],
+  [QUALITY_LEVELS['360p']]: AVAILABLE_RESOLUTIONS['360p'],
+  [QUALITY_LEVELS['480p']]: AVAILABLE_RESOLUTIONS['480p'],
+  [QUALITY_LEVELS['720p']]: AVAILABLE_RESOLUTIONS['720p'],
+  [QUALITY_LEVELS['1080p']]: AVAILABLE_RESOLUTIONS['1080p'],
 };
 
 /**

package/src/media/properties.js

@@ -1,5 +1,7 @@
 import {
+  ICE_STATE,
   MEETINGS,
+  PC_BAIL_TIMEOUT,
   QUALITY_LEVELS
 } from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
@@ -195,4 +197,99 @@ export default class MediaProperties {
     this.unsetLocalVideoTrack();
     this.unsetRemoteMedia();
   }
+
+  /**
+   * Waits until ice connection is established
+   *
+   * @returns {Promise<void>}
+   */
+  waitForIceConnectedState() {
+    const isIceConnected = () => (
+      this.peerConnection.iceConnectionState === ICE_STATE.CONNECTED ||
+        this.peerConnection.iceConnectionState === ICE_STATE.COMPLETED
+    );
+
+    if (isIceConnected()) {
+      return Promise.resolve();
+    }
+
+    return new Promise((resolve, reject) => {
+      let timer;
+
+      const iceListener = () => {
+        LoggerProxy.logger.log(`Media:properties#waitForIceConnectedState --> ice state: ${this.peerConnection.iceConnectionState}, conn state: ${this.peerConnection.connectionState}`);
+
+        if (isIceConnected()) {
+          clearTimeout(timer);
+          this.peerConnection.removeEventListener('iceconnectionstatechange', iceListener);
+          resolve();
+        }
+      };
+
+      timer = setTimeout(() => {
+        this.peerConnection.removeEventListener('iceconnectionstatechange', iceListener);
+        reject();
+      }, PC_BAIL_TIMEOUT);
+
+      this.peerConnection.addEventListener('iceconnectionstatechange', iceListener);
+    });
+  }
+
+  /**
+   * Returns the type of a connection that has been established
+   *
+   * @returns {Promise<'UDP' | 'TCP' | 'TURN-TLS' | 'TURN-TCP' | 'TURN-UDP' | 'unknown'>}
+   */
+  async getCurrentConnectionType() {
+    // we can only get the connection type after ICE connection has been established
+    await this.waitForIceConnectedState();
+
+    const allStatsReports = [];
+
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      const statsResult = await this.peerConnection.getStats();
+
+      statsResult.forEach((report) => allStatsReports.push(report));
+    }
+    catch (error) {
+      LoggerProxy.logger.warn(`Media:properties#getCurrentConnectionType --> getStats() failed: ${error}`);
+    }
+
+    const successfulCandidatePairs = allStatsReports.filter(
+      (report) => report.type === 'candidate-pair' && report.state?.toLowerCase() === 'succeeded'
+    );
+
+    let foundConnectionType = 'unknown';
+
+    // all of the successful pairs should have the same connection type, so just return the type for the first one
+    successfulCandidatePairs.some((pair) => {
+      const localCandidate = allStatsReports.find((report) => report.type === 'local-candidate' && report.id === pair.localCandidateId);
+
+      if (localCandidate === undefined) {
+        LoggerProxy.logger.warn(`Media:properties#getCurrentConnectionType --> failed to find local candidate "${pair.localCandidateId}" in getStats() results`);
+
+        return false;
+      }
+
+      let connectionType;
+
+      if (localCandidate.relayProtocol) {
+        connectionType = `TURN-${localCandidate.relayProtocol.toUpperCase()}`;
+      }
+      else {
+        connectionType = localCandidate.protocol?.toUpperCase(); // it will be UDP or TCP
+      }
+
+      if (connectionType) {
+        foundConnectionType = connectionType;
+
+        return true;
+      }
+
+      return false;
+    });
+
+    return foundConnectionType;
+  }
 }

package/src/meeting/index.js

@@ -1,5 +1,5 @@
 import uuid from 'uuid';
-import {cloneDeep, isEqual, pick} from 'lodash';
+import {cloneDeep, isEqual, pick, isString} from 'lodash';
 import {StatelessWebexPlugin} from '@webex/webex-core';
 import {Media as WebRTCMedia} from '@webex/internal-media-core';
 
@@ -36,7 +36,6 @@ import {
   _INCOMING_,
   _JOIN_,
   AUDIO,
-  CONNECTION_STATE,
   CONTENT,
   ENDED,
   EVENT_TRIGGERS,
@@ -58,7 +57,6 @@ import {
   ONLINE,
   OFFLINE,
   PASSWORD_STATUS,
-  PC_BAIL_TIMEOUT,
   PSTN_STATUS,
   QUALITY_LEVELS,
   RECORDING_STATE,
@@ -2746,7 +2744,7 @@ export default class Meeting extends StatelessWebexPlugin {
       const {localQualityLevel} = this.mediaProperties;
 
       if (Number(localQualityLevel.slice(0, -1)) > height) {
-        LoggerProxy.logger.error(`Meeting:index#setLocalVideoTrack --> Local video quality of ${localQualityLevel} not supported,
+        LoggerProxy.logger.warn(`Meeting:index#setLocalVideoTrack --> Local video quality of ${localQualityLevel} not supported,
          downscaling to highest possible resolution of ${height}p`);
 
         this.mediaProperties.setLocalQualityLevel(`${height}p`);
@@ -4014,6 +4012,16 @@ export default class Meeting extends StatelessWebexPlugin {
         LoggerProxy.logger.warn('Meeting:index#getMediaStreams --> Please use `meeting.shareScreen()` to manually start the screen share after successfully joining the meeting');
       }
 
+      if (audioVideo && isString(audioVideo)) {
+        if (Object.keys(VIDEO_RESOLUTIONS).includes(audioVideo)) {
+          this.mediaProperties.setLocalQualityLevel(audioVideo);
+          audioVideo = {video: VIDEO_RESOLUTIONS[audioVideo].video};
+        }
+        else {
+          throw new ParameterError(`${audioVideo} not supported. Either pass level from pre-defined resolutions or pass complete audioVideo object`);
+        }
+      }
+
       if (!audioVideo.video) {
         audioVideo = {...audioVideo, video: {...audioVideo.video, ...VIDEO_RESOLUTIONS[this.mediaProperties.localQualityLevel].video}};
       }
@@ -4246,129 +4254,110 @@ export default class Meeting extends StatelessWebexPlugin {
         enableRtx: this.config.enableRtx,
         enableExtmap: this.config.enableExtmap,
         setStartLocalSDPGenRemoteSDPRecvDelay: this.setStartLocalSDPGenRemoteSDPRecvDelay.bind(this)
-      })
-        .then((peerConnection) => this.getDevices().then((devices) => {
-          MeetingUtil.handleDeviceLogging(devices);
+      }))
+      .then((peerConnection) => this.getDevices().then((devices) => {
+        MeetingUtil.handleDeviceLogging(devices);
 
-          return peerConnection;
-        }))
-        .then((peerConnection) => {
-          this.handleMediaLogging(this.mediaProperties);
-          LoggerProxy.logger.info(`${LOG_HEADER} PeerConnection Received from attachMedia `);
+        return peerConnection;
+      }))
+      .then((peerConnection) => {
+        this.handleMediaLogging(this.mediaProperties);
+        LoggerProxy.logger.info(`${LOG_HEADER} PeerConnection Received from attachMedia `);
+
+        this.setRemoteStream(peerConnection);
+        if (this.config.stats.enableStatsAnalyzer) {
+          // TODO: ** Dont re create StatsAnalyzer on reconnect or rejoin
+          this.networkQualityMonitor = new NetworkQualityMonitor(this.config.stats);
+          this.statsAnalyzer = new StatsAnalyzer(this.config.stats, this.networkQualityMonitor);
+          this.setupStatsAnalyzerEventHandlers();
+          this.networkQualityMonitor.on(EVENT_TRIGGERS.NETWORK_QUALITY, this.sendNetworkQualityEvent.bind(this));
+        }
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error(`${LOG_HEADER} Error adding media , setting up peerconnection, `, error);
 
-          this.setRemoteStream(peerConnection);
-          if (this.config.stats.enableStatsAnalyzer) {
-            // TODO: ** Dont re create StatsAnalyzer on reconnect or rejoin
-            this.networkQualityMonitor = new NetworkQualityMonitor(this.config.stats);
-            this.statsAnalyzer = new StatsAnalyzer(this.config.stats, this.networkQualityMonitor);
-            this.setupStatsAnalyzerEventHandlers();
-            this.networkQualityMonitor.on(EVENT_TRIGGERS.NETWORK_QUALITY, this.sendNetworkQualityEvent.bind(this));
+        Metrics.sendBehavioralMetric(
+          BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE,
+          {
+            correlation_id: this.correlationId,
+            locus_id: this.locusUrl.split('/').pop(),
+            reason: error.message,
+            stack: error.stack,
+            turnDiscoverySkippedReason,
+            turnServerUsed
           }
-        })
-        .catch((error) => {
-          LoggerProxy.logger.error(`${LOG_HEADER} Error adding media , setting up peerconnection, `, error);
-
-          Metrics.sendBehavioralMetric(
-            BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE,
-            {
-              correlation_id: this.correlationId,
-              locus_id: this.locusUrl.split('/').pop(),
-              reason: error.message,
-              stack: error.stack,
-              turnDiscoverySkippedReason,
-              turnServerUsed
-            }
-          );
+        );
 
-          throw error;
-        })
-        .then(() => new Promise((resolve, reject) => {
-          let timerCount = 0;
+        throw error;
+      })
+      .then(() => new Promise((resolve, reject) => {
+        let timerCount = 0;
 
-          // eslint-disable-next-line func-names
-          // eslint-disable-next-line prefer-arrow-callback
-          if (this.type === _CALL_) {
+        // eslint-disable-next-line func-names
+        // eslint-disable-next-line prefer-arrow-callback
+        if (this.type === _CALL_) {
+          resolve();
+        }
+        const joiningTimer = setInterval(() => {
+          timerCount += 1;
+          if (this.meetingState === FULL_STATE.ACTIVE) {
+            clearInterval(joiningTimer);
             resolve();
           }
-          const joiningTimer = setInterval(() => {
-            timerCount += 1;
-            if (this.meetingState === FULL_STATE.ACTIVE) {
-              clearInterval(joiningTimer);
-              resolve();
-            }
 
-            if (timerCount === 4) {
-              clearInterval(joiningTimer);
-              reject(new Error('Meeting is still not active '));
-            }
-          }, 1000);
+          if (timerCount === 4) {
+            clearInterval(joiningTimer);
+            reject(new Error('Meeting is still not active '));
+          }
+        }, 1000);
+      }))
+      .then(() =>
+        logRequest(this.roap
+          .sendRoapMediaRequest({
+            sdp: this.mediaProperties.peerConnection.sdp,
+            roapSeq: this.roapSeq,
+            meeting: this // or can pass meeting ID
+          }), {
+          header: `${LOG_HEADER} Send Roap Media Request.`,
+          success: `${LOG_HEADER} Successfully send roap media request`,
+          failure: `${LOG_HEADER} Error joining the call on send roap media request, `
         }))
-        .then(() =>
-          logRequest(this.roap
-            .sendRoapMediaRequest({
-              sdp: this.mediaProperties.peerConnection.sdp,
-              roapSeq: this.roapSeq,
-              meeting: this // or can pass meeting ID
-            }), {
-            header: `${LOG_HEADER} Send Roap Media Request.`,
-            success: `${LOG_HEADER} Successfully send roap media request`,
-            failure: `${LOG_HEADER} Error joining the call on send roap media request, `
-          }))
-        .then(() => {
-          const {peerConnection} = this.mediaProperties;
-
-          return new Promise((resolve, reject) => {
-            if (peerConnection.connectionState === CONNECTION_STATE.CONNECTED) {
-              LoggerProxy.logger.info(`${LOG_HEADER} PeerConnection CONNECTED`);
-
-              resolve(peerConnection);
-
-              return;
-            }
-            // Check if Peer Connection is STABLE (connected)
-            const stabilityTimeout = setTimeout(() => {
-              if (peerConnection.connectionState !== CONNECTION_STATE.CONNECTED) {
-                // TODO: Fix this after the error code pr goes in
-                reject(createMeetingsError(30202, 'Meeting connection failed'));
-              }
-              else {
-                LoggerProxy.logger.info(`${LOG_HEADER} PeerConnection CONNECTED`);
-                resolve(peerConnection);
-              }
-            }, PC_BAIL_TIMEOUT);
-
-            this.once(EVENT_TRIGGERS.MEDIA_READY, () => {
-              LoggerProxy.logger.info(`${LOG_HEADER} PeerConnection CONNECTED, clearing stability timer.`);
-              clearTimeout(stabilityTimeout);
-              resolve(peerConnection);
-            });
-          });
-        })
-        .then(() => {
-          if (mediaSettings && mediaSettings.sendShare && localShare) {
-            if (this.state === MEETING_STATE.STATES.JOINED) {
-              return this.share();
-            }
+      .then(
+        () => this.mediaProperties.waitForIceConnectedState()
+          .catch(() => {
+            throw createMeetingsError(30202, 'Meeting connection failed');
+          })
+      )
+      .then(() => {
+        LoggerProxy.logger.info(`${LOG_HEADER} PeerConnection CONNECTED`);
 
-            // When the self state changes to JOINED then request the floor
-            this.floorGrantPending = true;
+        if (mediaSettings && mediaSettings.sendShare && localShare) {
+          if (this.state === MEETING_STATE.STATES.JOINED) {
+            return this.share();
           }
 
-          Metrics.sendBehavioralMetric(
-            BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS,
-            {
-              correlation_id: this.correlationId,
-              locus_id: this.locusUrl.split('/').pop()
-            }
-          );
+          // When the self state changes to JOINED then request the floor
+          this.floorGrantPending = true;
+        }
 
-          return Promise.resolve();
-        }))
+        return {};
+      })
+      .then(() => this.mediaProperties.getCurrentConnectionType())
+      .then((connectionType) => {
+        Metrics.sendBehavioralMetric(
+          BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS,
+          {
+            correlation_id: this.correlationId,
+            locus_id: this.locusUrl.split('/').pop(),
+            connectionType
+          }
+        );
+      })
       .catch((error) => {
         // Clean up stats analyzer, peer connection, and turn off listeners
         const stopStatsAnalyzer = (this.statsAnalyzer) ? this.statsAnalyzer.stopAnalyzer() : Promise.resolve();
 
-        stopStatsAnalyzer
+        return stopStatsAnalyzer
           .then(() => {
             this.statsAnalyzer = null;