@webex/plugin-meetings 2.12.1 → 2.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "2.12.1",
+  "version": "2.13.0",
   "description": "",
   "license": "MIT",
   "contributors": [
@@ -24,21 +24,21 @@
   },
   "dependencies": {
     "@babel/runtime-corejs2": "^7.14.8",
-    "@webex/webex-core": "2.12.1",
-    "@webex/internal-plugin-mercury": "2.12.1",
-    "@webex/internal-plugin-conversation": "2.12.1",
+    "@webex/webex-core": "2.13.0",
+    "@webex/internal-plugin-mercury": "2.13.0",
+    "@webex/internal-plugin-conversation": "2.13.0",
     "webrtc-adapter": "^7.7.0",
     "lodash": "^4.17.21",
     "uuid": "^3.3.2",
     "global": "^4.4.0",
     "ip-anonymize": "^0.1.0",
-    "@webex/common": "2.12.1",
+    "@webex/common": "2.13.0",
     "bowser": "^2.11.0",
     "sdp-transform": "^2.12.0",
     "readable-stream": "^3.6.0",
-    "@webex/common-timers": "2.12.1",
+    "@webex/common-timers": "2.13.0",
     "btoa": "^1.2.1",
-    "@webex/internal-media-core": "^0.0.4-beta",
+    "@webex/internal-media-core": "^0.0.6-beta",
     "javascript-state-machine": "^3.1.0",
     "envify": "^4.1.0"
   }

package/src/constants.js

@@ -1241,3 +1241,10 @@ export const MEETING_INFO_FAILURE_REASON = {
   WRONG_CAPTCHA: 'WRONG_CAPTCHA', // wbxappapi requires a captcha code or a wrong captcha code was provided
   OTHER: 'OTHER' // any other error (network, etc)
 };
+
+export const BNR_STATUS = {
+  SHOULD_ENABLE: 'SHOULD_ENABLE',
+  ENABLED: 'ENABLED',
+  SHOULD_DISABLE: 'SHOULD_DISABLE',
+  NOT_ENABLED: 'NOT_ENABLED'
+};

package/src/meeting/index.js

@@ -72,6 +72,7 @@ import {
   STATS,
   VIDEO_RESOLUTIONS,
   VIDEO,
+  BNR_STATUS,
   HTTP_VERBS
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
@@ -914,6 +915,14 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.meetingInfoFailureReason = undefined;
 
+    /**
+     * Indicates the current status of BNR in the meeting
+     * @type {BNR_STATUS}
+     * @private
+     * @memberof Meeting
+     */
+    this.bnrStatus = BNR_STATUS.NOT_ENABLED;
+
     this.setUpLocusInfoListeners();
     this.locusInfo.init(attrs.locus ? attrs.locus : {});
     this.hasJoinedOnce = false;
@@ -4482,18 +4491,23 @@ export default class Meeting extends StatelessWebexPlugin {
    * @public
    * @memberof Meeting
    */
-  updateAudio(options) {
+  async updateAudio(options) {
     if (!this.canUpdateMedia()) {
       return this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.AUDIO, options);
     }
     const {sendAudio, receiveAudio, stream} = options;
     const {audioTransceiver} = this.mediaProperties.peerConnection;
-    const track = MeetingUtil.getTrack(stream).audioTrack;
+    let track = MeetingUtil.getTrack(stream).audioTrack;
 
     if (typeof sendAudio !== 'boolean' || typeof receiveAudio !== 'boolean') {
       return Promise.reject(new ParameterError('Pass sendAudio and receiveAudio parameter'));
     }
 
+    if (sendAudio && !this.isAudioMuted() && (this.bnrStatus === BNR_STATUS.ENABLED || this.bnrStatus === BNR_STATUS.SHOULD_ENABLE)) {
+      track = await this.internal_enableBNR(track);
+      this.bnrStatus = BNR_STATUS.ENABLED;
+    }
+
     return MeetingUtil.validateOptions({sendAudio, localStream: stream})
       .then(() => {
         let previousMediaDirection = {};
@@ -5750,6 +5764,38 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   };
 
+  /**
+   * Internal API to return status of BNR
+   * @returns {Boolean}
+   * @public
+   * @memberof Meeting
+   */
+  isBnrEnabled() {
+    return this.bnrStatus === BNR_STATUS.ENABLED;
+  }
+
+  /**
+   * Internal API to obtain BNR enabled MediaStream
+   * @returns {Promise<MediaStreamTrack>}
+   * @private
+   * @param {MedaiStreamTrack} audioTrack from updateAudio
+   * @memberof Meeting
+   */
+  async internal_enableBNR(audioTrack) {
+    try {
+      LoggerProxy.logger.info('Meeting:index#internal_enableBNR. Internal enable BNR called');
+      const bnrAudioTrack = await WebRTCMedia.Effects.BNR.enableBNR(audioTrack);
+
+      LoggerProxy.logger.info('Meeting:index#internal_enableBNR. BNR enabled track obtained from WebRTC & returned as stream');
+
+      return bnrAudioTrack;
+    }
+    catch (error) {
+      LoggerProxy.logger.error('Meeting:index#internal_enableBNR.', error);
+      throw error;
+    }
+  }
+
   /**
    * enableBNR API
    * @returns {Promise<Boolean>}
@@ -5764,24 +5810,29 @@ export default class Meeting extends StatelessWebexPlugin {
       if (typeof this.mediaProperties === 'undefined' || typeof this.mediaProperties.audioTrack === 'undefined') {
         throw new Error("Meeting doesn't have an audioTrack attached");
       }
-      this.mediaProperties.audioTrack = await WebRTCMedia.Effects.BNR.enableBNR(this.mediaProperties.audioTrack);
+      else if (this.isAudioMuted()) {
+        throw new Error('Cannot enable BNR while meeting is muted');
+      }
+
+
+      this.bnrStatus = BNR_STATUS.SHOULD_ENABLE;
+
       const audioStream = MediaUtil.createMediaStream([this.mediaProperties.audioTrack]);
 
-      LoggerProxy.logger.info('Meeting:index#enableBNR. BNR enabled track obtained from WebRTC & sent to updateAudio');
+      LoggerProxy.logger.info('Meeting:index#enableBNR. MediaStream created from meeting & sent to updateAudio');
       await this.updateAudio({
         sendAudio: true,
-        receiveAudio: true,
+        receiveAudio: this.mediaProperties.mediaDirection.receiveAudio,
         stream: audioStream
       });
-      this.isBnrEnabled = true;
+      this.bnrStatus = BNR_STATUS.ENABLED;
       isSuccess = true;
       Metrics.sendBehavioralMetric(
         BEHAVIORAL_METRICS.ENABLE_BNR_SUCCESS,
       );
     }
     catch (error) {
-      LoggerProxy.logger.error(`Meeting:index#enableBNR. ${error}`);
-
+      this.bnrStatus = BNR_STATUS.NOT_ENABLED;
       Metrics.sendBehavioralMetric(
         BEHAVIORAL_METRICS.ENABLE_BNR_FAILURE,
         {
@@ -5789,7 +5840,7 @@ export default class Meeting extends StatelessWebexPlugin {
           stack: error.stack
         }
       );
-
+      LoggerProxy.logger.error('Meeting:index#enableBNR.', error);
       throw error;
     }
 
@@ -5807,19 +5858,27 @@ export default class Meeting extends StatelessWebexPlugin {
     let isSuccess = false;
 
     try {
-      if (typeof this.mediaProperties === 'undefined' || typeof this.mediaProperties.audioTrack === 'undefined') {
+      if (!this.isBnrEnabled()) {
+        throw new Error('Can not disable as BNR is not enabled');
+      }
+      else if (typeof this.mediaProperties === 'undefined' || typeof this.mediaProperties.audioTrack === 'undefined') {
         throw new Error("Meeting doesn't have an audioTrack attached");
       }
-      this.mediaProperties.audioTrack = WebRTCMedia.Effects.BNR.disableBNR(this.mediaProperties.audioTrack);
-      const audioStream = MediaUtil.createMediaStream([this.mediaProperties.audioTrack]);
+      const audioTrack = WebRTCMedia.Effects.BNR.disableBNR(this.mediaProperties.audioTrack);
+      const audioStream = MediaUtil.createMediaStream([audioTrack]);
 
       LoggerProxy.logger.info('Meeting:index#disableBNR. Raw media track obtained from WebRTC & sent to updateAudio');
+
+      this.bnrStatus = BNR_STATUS.SHOULD_DISABLE;
+
       await this.updateAudio({
         sendAudio: true,
-        receiveAudio: true,
+        receiveAudio: this.mediaProperties.mediaDirection.receiveAudio,
         stream: audioStream
       });
-      this.isBnrEnabled = false;
+
+      this.bnrStatus = BNR_STATUS.NOT_ENABLED;
+
       isSuccess = true;
 
       Metrics.sendBehavioralMetric(
@@ -5827,6 +5886,7 @@ export default class Meeting extends StatelessWebexPlugin {
       );
     }
     catch (error) {
+      this.bnrStatus = BNR_STATUS.ENABLED;
       LoggerProxy.logger.error(`Meeting:index#disableBNR. ${error}`);
 
       Metrics.sendBehavioralMetric(

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

@@ -456,13 +456,26 @@ describe('plugin-meetings', () => {
         });
       });
       describe('BNR', () => {
+        const fakeMediaTrack = () => ({
+          id: Date.now().toString(),
+          stop: () => {},
+          readyState: 'live',
+          enabled: true,
+          getSettings: () => ({
+            sampleRate: 48000
+          })
+        });
+
         class FakeMediaStream {
-          constructor() {
+          constructor(tracks) {
             this.active = false;
             this.id = '5146425f-c240-48cc-b86b-27d422988fb7';
+            this.tracks = tracks;
           }
 
           addTrack = () => undefined;
+
+          getAudioTracks = () => this.tracks;
         }
 
         class FakeAudioContext {
@@ -523,6 +536,12 @@ describe('plugin-meetings', () => {
             this.readyState = 'live';
             this.contentHint = '';
           }
+
+          getSettings() {
+            return {
+              sampleRate: 48000
+            };
+          }
         }
         Object.defineProperty(global, 'MediaStream', {
           writable: true,
@@ -544,24 +563,21 @@ describe('plugin-meetings', () => {
           value: FakeMediaStreamTrack,
         });
 
-        beforeEach(async () => {
+        beforeEach(() => {
           meeting.canUpdateMedia = sinon.stub().returns(true);
           MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve());
           MeetingUtil.updateTransceiver = sinon.stub();
-          const fakeMediaTrack = () => ({
-            stop: () => {},
-            readyState: 'live',
-            getSettings: () => ({
-              sampleRate: 48000
-            })
-          });
 
           meeting.getMediaStreams = sinon.stub().returns(Promise.resolve());
           sinon.replace(meeting, 'addMedia', () => {
             sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack());
+            sinon.stub(meeting.mediaProperties, 'mediaDirection').value({
+              receiveAudio: true
+            });
           });
-          await meeting.getMediaStreams();
-          await meeting.addMedia();
+
+          // eslint-disable-next-line no-undef
+          MediaUtil.createMediaStream = sinon.stub().returns(new MediaStream([fakeMediaTrack()]));
         });
 
         describe('#enableBNR', () => {
@@ -578,22 +594,37 @@ describe('plugin-meetings', () => {
           });
 
           describe('after audio attached to meeting', () => {
+            beforeEach(async () => {
+              await meeting.getMediaStreams();
+              await meeting.addMedia();
+            });
+
             it('should return true for appropriate sample rate', async () => {
               const response = await meeting.enableBNR();
 
+              assert(Metrics.sendBehavioralMetric.calledOnce);
+              assert.calledWith(
+                Metrics.sendBehavioralMetric,
+                BEHAVIORAL_METRICS.ENABLE_BNR_SUCCESS,
+              );
+
               assert.equal(response, true);
             });
 
-            it('should throw error for inappropriate sample rate and send error metrics', async () => {
-              const fakeMediaTrack = () => ({
-                stop: () => {},
-                readyState: 'live',
-                getSettings: () => ({
-                  sampleRate: 49000
-                })
-              });
+            it('should throw error if meeting audio is muted', async () => {
+              await meeting.getMediaStreams();
+              await meeting.addMedia();
+              const handleClientRequest = (meeting, mute) => {
+                meeting.mediaProperties.audioTrack.enabled = !mute;
 
-              sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack());
+                return Promise.resolve();
+              };
+              const isMuted = () => !meeting.mediaProperties.audioTrack.enabled;
+
+              meeting.mediaId = 'mediaId';
+              meeting.audio = {handleClientRequest, isMuted};
+              meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
+              await meeting.muteAudio();
               await meeting.enableBNR().catch((err) => {
                 assert(Metrics.sendBehavioralMetric.calledOnce);
                 assert.calledWith(
@@ -603,29 +634,56 @@ describe('plugin-meetings', () => {
                     stack: err.stack
                   }
                 );
-                assert.equal(err.message, 'Sample rate of 49000 is not supported.');
+                assert.equal(err.message, 'Cannot enable BNR while meeting is muted');
               });
             });
 
-            it('should send metrics for enable bnr success', async () => {
-              const response = await meeting.enableBNR();
+            it('should throw error for inappropriate sample rate and send error metrics', async () => {
+              const fakeMediaTrack = () => ({
+                id: Date.now().toString(),
+                stop: () => {},
+                readyState: 'live',
+                getSettings: () => ({
+                  sampleRate: 49000
+                })
+              });
 
-              assert(Metrics.sendBehavioralMetric.calledOnce);
-              assert.calledWith(
-                Metrics.sendBehavioralMetric,
-                BEHAVIORAL_METRICS.ENABLE_BNR_SUCCESS,
-              );
-              assert.equal(response, true);
+              sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack());
+
+              // eslint-disable-next-line no-undef
+              MediaUtil.createMediaStream = sinon.stub().returns(new MediaStream([fakeMediaTrack()]));
+
+              await meeting.enableBNR()
+                .then(() => {
+                  assert.fail('The expected Error was not thrown.');
+                })
+                .catch((err) => {
+                  assert(Metrics.sendBehavioralMetric.calledOnce);
+                  assert.calledWith(
+                    Metrics.sendBehavioralMetric,
+                    BEHAVIORAL_METRICS.ENABLE_BNR_FAILURE, {
+                      reason: err.message,
+                      stack: err.stack
+                    }
+                  );
+                  assert.equal(err.message, 'Sample rate of 49000 is not supported.');
+                });
             });
           });
         });
 
         describe('#disableBNR', () => {
+          beforeEach(async () => {
+            await meeting.getMediaStreams();
+            await meeting.addMedia();
+          });
+
           it('should have #disableBnr', () => {
             assert.exists(meeting.disableBNR);
           });
 
           it('should return true if bnr is disabled on bnr enabled track', async () => {
+            await meeting.enableBNR();
             const response = await meeting.disableBNR();
 
             assert.equal(response, true);