@webex/plugin-meetings 2.34.0 → 3.0.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "2.34.0",
+  "version": "3.0.0-beta.0",
   "description": "",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "contributors": [
@@ -13,9 +13,13 @@
   ],
   "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"
+    "node": ">=16"
   },
   "browserify": {
     "transform": [
@@ -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": "3.0.0-beta.0",
+    "@webex/test-helper-chai": "3.0.0-beta.0",
+    "@webex/test-helper-mocha": "3.0.0-beta.0",
+    "@webex/test-helper-mock-webex": "3.0.0-beta.0",
+    "@webex/test-helper-retry": "3.0.0-beta.0",
+    "@webex/test-helper-test-users": "3.0.0-beta.0",
     "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": "3.0.0-beta.0",
     "@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": "3.0.0-beta.0",
+    "@webex/internal-plugin-device": "3.0.0-beta.0",
+    "@webex/internal-plugin-mercury": "3.0.0-beta.0",
+    "@webex/internal-plugin-metrics": "3.0.0-beta.0",
+    "@webex/internal-plugin-support": "3.0.0-beta.0",
+    "@webex/internal-plugin-user": "3.0.0-beta.0",
+    "@webex/plugin-people": "3.0.0-beta.0",
+    "@webex/plugin-rooms": "3.0.0-beta.0",
     "@webex/ts-sdp": "^1.0.1",
-    "@webex/webex-core": "2.34.0",
+    "@webex/webex-core": "3.0.0-beta.0",
     "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';
 
@@ -2746,7 +2746,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 +4014,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}};
       }

package/test/unit/spec/media/properties.ts

@@ -0,0 +1,305 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import MediaProperties from '@webex/plugin-meetings/src/media/properties';
+import MediaUtil from '@webex/plugin-meetings/src/media/util';
+import testUtils from '../../../utils/testUtils';
+import {PC_BAIL_TIMEOUT} from '@webex/plugin-meetings/src/constants';
+import {Defer} from '@webex/common';
+
+describe('MediaProperties', () => {
+  let mediaProperties;
+  let mockPc;
+  let clock;
+
+  beforeEach(() => {
+    clock = sinon.useFakeTimers();
+
+    mockPc = {
+      getStats: sinon.stub().resolves([]),
+      addEventListener: sinon.stub(),
+      removeEventListener: sinon.stub(),
+      iceConnectionState: 'connected',
+    };
+
+    sinon.stub(MediaUtil, 'createPeerConnection').returns(mockPc);
+
+    mediaProperties = new MediaProperties();
+  });
+
+  afterEach(() => {
+    clock.restore();
+    sinon.restore();
+  });
+  describe('waitForIceConnectedState', () => {
+    it('resolves immediately if ice state is connected', async () => {
+      mockPc.iceConnectionState = 'connected';
+
+      await mediaProperties.waitForIceConnectedState();
+    });
+    it('resolves immediately if ice state is completed', async () => {
+      mockPc.iceConnectionState = 'completed';
+
+      await mediaProperties.waitForIceConnectedState();
+    });
+    it('rejects after timeout if ice state does not reach connected/completed', async () => {
+      mockPc.iceConnectionState = 'connecting';
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaProperties
+        .waitForIceConnectedState()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch(() => {
+          promiseRejected = true;
+        });
+
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, false);
+
+      await clock.tickAsync(PC_BAIL_TIMEOUT);
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, true);
+
+      // check that listener was registered and removed
+      assert.calledOnce(mockPc.addEventListener);
+      assert.equal(mockPc.addEventListener.getCall(0).args[0], 'iceconnectionstatechange');
+      const listener = mockPc.addEventListener.getCall(0).args[1];
+
+      assert.calledOnce(mockPc.removeEventListener);
+      assert.calledWith(mockPc.removeEventListener, 'iceconnectionstatechange', listener);
+    });
+
+    ['connected', 'completed'].forEach((successIceState) =>
+      it(`resolves when ice state reaches ${successIceState}`, async () => {
+        mockPc.iceConnectionState = 'connecting';
+
+        const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
+
+        let promiseResolved = false;
+        let promiseRejected = false;
+
+        mediaProperties
+          .waitForIceConnectedState()
+          .then(() => {
+            promiseResolved = true;
+          })
+          .catch(() => {
+            promiseRejected = true;
+          });
+
+        assert.equal(promiseResolved, false);
+        assert.equal(promiseRejected, false);
+
+        // check the right listener was registered
+        assert.calledOnce(mockPc.addEventListener);
+        assert.equal(mockPc.addEventListener.getCall(0).args[0], 'iceconnectionstatechange');
+        const listener = mockPc.addEventListener.getCall(0).args[1];
+
+        // call the listener and pretend we are now connected
+        mockPc.iceConnectionState = successIceState;
+        listener();
+        await testUtils.flushPromises();
+
+        assert.equal(promiseResolved, true);
+        assert.equal(promiseRejected, false);
+
+        // check that listener was removed
+        assert.calledOnce(mockPc.removeEventListener);
+        assert.calledWith(mockPc.removeEventListener, 'iceconnectionstatechange', listener);
+
+        assert.calledOnce(clearTimeoutSpy);
+      })
+    );
+  });
+
+  describe('getCurrentConnectionType', () => {
+    it('calls waitForIceConnectedState', async () => {
+      const spy = sinon.stub(mediaProperties, 'waitForIceConnectedState');
+
+      await mediaProperties.getCurrentConnectionType();
+
+      assert.calledOnce(spy);
+    });
+    it('calls getStats() only after waitForIceConnectedState resolves', async () => {
+      const waitForIceConnectedStateResult = new Defer();
+
+      const waitForIceConnectedStateStub = sinon
+        .stub(mediaProperties, 'waitForIceConnectedState')
+        .returns(waitForIceConnectedStateResult.promise);
+
+      const result = mediaProperties.getCurrentConnectionType();
+
+      await testUtils.flushPromises();
+
+      assert.called(waitForIceConnectedStateStub);
+      assert.notCalled(mockPc.getStats);
+
+      waitForIceConnectedStateResult.resolve();
+      await testUtils.flushPromises();
+
+      assert.called(mockPc.getStats);
+      await result;
+    });
+    it('rejects if waitForIceConnectedState rejects', async () => {
+      const waitForIceConnectedStateResult = new Defer();
+
+      const waitForIceConnectedStateStub = sinon
+        .stub(mediaProperties, 'waitForIceConnectedState')
+        .returns(waitForIceConnectedStateResult.promise);
+
+      const result = mediaProperties.getCurrentConnectionType();
+
+      await testUtils.flushPromises();
+
+      assert.called(waitForIceConnectedStateStub);
+
+      waitForIceConnectedStateResult.reject(new Error('fake error'));
+      await testUtils.flushPromises();
+
+      assert.notCalled(mockPc.getStats);
+
+      await assert.isRejected(result);
+    });
+    it('returns "unknown" if getStats() fails', async () => {
+      mockPc.getStats.rejects(new Error());
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'unknown');
+    });
+
+    it('returns "unknown" if getStats() returns no candidate pairs', async () => {
+      mockPc.getStats.resolves([{type: 'something', id: '1234'}]);
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'unknown');
+    });
+
+    it('returns "unknown" if getStats() returns no successful candidate pair', async () => {
+      mockPc.getStats.resolves([{type: 'candidate-pair', id: '1234', state: 'inprogress'}]);
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'unknown');
+    });
+
+    it('returns "unknown" if getStats() returns a successful candidate pair but local candidate is missing', async () => {
+      mockPc.getStats.resolves([
+        {type: 'candidate-pair', id: '1234', state: 'succeeded', localCandidateId: 'wrong id'},
+      ]);
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'unknown');
+    });
+
+    it('returns "UDP" if getStats() returns a successful candidate pair with udp local candidate', async () => {
+      mockPc.getStats.resolves([
+        {
+          type: 'candidate-pair',
+          id: 'some candidate pair id',
+          state: 'succeeded',
+          localCandidateId: 'local candidate id',
+        },
+        {type: 'local-candidate', id: 'some other candidate id', protocol: 'tcp'},
+        {type: 'local-candidate', id: 'local candidate id', protocol: 'udp'},
+      ]);
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'UDP');
+    });
+
+    it('returns "TCP" if getStats() returns a successful candidate pair with tcp local candidate', async () => {
+      mockPc.getStats.resolves([
+        {
+          type: 'candidate-pair',
+          id: 'some candidate pair id',
+          state: 'succeeded',
+          localCandidateId: 'some candidate id',
+        },
+        {type: 'local-candidate', id: 'some other candidate id', protocol: 'udp'},
+        {type: 'local-candidate', id: 'some candidate id', protocol: 'tcp'},
+      ]);
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'TCP');
+    });
+
+    [
+      {relayProtocol: 'tls', expectedConnectionType: 'TURN-TLS'},
+      {relayProtocol: 'tcp', expectedConnectionType: 'TURN-TCP'},
+      {relayProtocol: 'udp', expectedConnectionType: 'TURN-UDP'},
+    ].forEach(({relayProtocol, expectedConnectionType}) =>
+      it(`returns "${expectedConnectionType}" if getStats() returns a successful candidate pair with a local candidate with relayProtocol=${relayProtocol}`, async () => {
+        mockPc.getStats.resolves([
+          {
+            type: 'candidate-pair',
+            id: 'some candidate pair id',
+            state: 'succeeded',
+            localCandidateId: 'selected candidate id',
+          },
+          {
+            type: 'candidate-pair',
+            id: 'some other candidate pair id',
+            state: 'failed',
+            localCandidateId: 'some other candidate id 1',
+          },
+          {type: 'local-candidate', id: 'some other candidate id 1', protocol: 'udp'},
+          {type: 'local-candidate', id: 'some other candidate id 2', protocol: 'tcp'},
+          {
+            type: 'local-candidate',
+            id: 'selected candidate id',
+            protocol: 'udp',
+            relayProtocol,
+          },
+        ]);
+
+        const connectionType = await mediaProperties.getCurrentConnectionType();
+        assert.equal(connectionType, expectedConnectionType);
+      })
+    );
+
+    it('returns connection type of the first successful candidate pair', async () => {
+      // in real life this will never happen and all active candidate pairs will have same transport,
+      // but here we're simulating a situation where they have different transports and just checking
+      // that the code still works and just returns the first one
+      mockPc.getStats.resolves([
+        {
+          type: 'inbound-rtp',
+          id: 'whatever',
+        },
+        {
+          type: 'candidate-pair',
+          id: 'some candidate pair id',
+          state: 'succeeded',
+          localCandidateId: '1st selected candidate id',
+        },
+        {
+          type: 'candidate-pair',
+          id: 'some other candidate pair id',
+          state: 'succeeded',
+          localCandidateId: '2nd selected candidate id',
+        },
+        {type: 'local-candidate', id: 'some other candidate id 1', protocol: 'udp'},
+        {type: 'local-candidate', id: 'some other candidate id 2', protocol: 'tcp'},
+        {
+          type: 'local-candidate',
+          id: '1st selected candidate id',
+          protocol: 'udp',
+          relayProtocol: 'tls',
+        },
+        {
+          type: 'local-candidate',
+          id: '2nd selected candidate id',
+          protocol: 'udp',
+          relayProtocol: 'tcp',
+        },
+      ]);
+
+      const connectionType = await mediaProperties.getCurrentConnectionType();
+      assert.equal(connectionType, 'TURN-TLS');
+    });
+  });
+});

package/test/unit/spec/meeting/index.js

@@ -42,6 +42,7 @@ import BrowserDetection from '@webex/plugin-meetings/src/common/browser-detectio
 import Metrics from '@webex/plugin-meetings/src/metrics';
 import {trigger, eventType} from '@webex/plugin-meetings/src/metrics/config';
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
+import {IceGatheringFailed} from '@webex/plugin-meetings/src/common/errors/webex-errors';
 
 import locus from '../fixture/locus';
 import {
@@ -910,6 +911,8 @@ describe('plugin-meetings', () => {
 
         beforeEach(() => {
           meeting.mediaProperties.setMediaDirection = sinon.stub().returns(true);
+          meeting.mediaProperties.waitForIceConnectedState = sinon.stub().resolves();
+          meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
           meeting.audio = muteStateStub;
           meeting.video = muteStateStub;
           Media.attachMedia = sinon.stub().returns(Promise.resolve([test1, test2]));
@@ -1151,6 +1154,41 @@ describe('plugin-meetings', () => {
           });
         });
 
+        it('should reject if waitForIceConnectedState() rejects', async () => {
+          meeting.meetingState = 'ACTIVE';
+          meeting.mediaProperties.waitForIceConnectedState.rejects(new Error('fake error'));
+
+          let errorThrown = false;
+
+          await meeting.addMedia({
+            mediaSettings: {}
+          })
+            .catch((error) => {
+              assert.equal(error.code, IceGatheringFailed.CODE);
+              errorThrown = true;
+            });
+
+          assert.isTrue(errorThrown);
+        });
+
+        it('should send ADD_MEDIA_SUCCESS metrics', async () => {
+          meeting.meetingState = 'ACTIVE';
+          await meeting.addMedia({
+            mediaSettings: {}
+          });
+
+          assert.calledOnce(Metrics.sendBehavioralMetric);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              connectionType: 'udp'
+            }
+          );
+        });
+
         describe('handles StatsAnalyzer events', () => {
           let prevConfigValue;
           let statsAnalyzerStub;