@webex/plugin-meetings 2.4.1 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "2.4.1",
+  "version": "2.6.0",
   "description": "",
   "license": "MIT",
   "contributors": [
@@ -24,20 +24,21 @@
   },
   "dependencies": {
     "@babel/runtime-corejs2": "^7.14.8",
-    "@webex/webex-core": "2.4.1",
-    "@webex/internal-plugin-mercury": "2.4.1",
-    "@webex/internal-plugin-conversation": "2.4.1",
+    "@webex/webex-core": "2.6.0",
+    "@webex/internal-plugin-mercury": "2.6.0",
+    "@webex/internal-plugin-conversation": "2.6.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.4.1",
+    "@webex/common": "2.6.0",
     "bowser": "^2.11.0",
     "sdp-transform": "^2.12.0",
     "readable-stream": "^3.6.0",
-    "@webex/common-timers": "2.4.1",
+    "@webex/common-timers": "2.6.0",
     "btoa": "^1.2.1",
+    "@webex/internal-media-core": "^0.0.4-beta",
     "javascript-state-machine": "^3.1.0",
     "envify": "^4.1.0"
   }

package/src/meeting/index.js

@@ -1,6 +1,7 @@
 import uuid from 'uuid';
 import {cloneDeep, isEqual, pick} from 'lodash';
 import {StatelessWebexPlugin} from '@webex/webex-core';
+import {Media as WebRTCMedia} from '@webex/internal-media-core';
 
 import {
   MeetingNotActiveError, createMeetingsError, UserInLobbyError,
@@ -83,6 +84,7 @@ import RoapCollection from '../roap/collection';
 
 import InMeetingActions from './in-meeting-actions';
 
+
 const {isBrowser} = BrowserDetection();
 
 const logRequest = (request, {header = '', success = '', failure = ''}) => {
@@ -5739,4 +5741,72 @@ export default class Meeting extends StatelessWebexPlugin {
       this.transcription = undefined;
     }
   };
+
+  /**
+   * enableBNR API
+   * @returns {Promise<Boolean>}
+   * @public
+   * @memberof Meeting
+   */
+  async enableBNR() {
+    LoggerProxy.logger.info('Meeting:index#enableBNR. Enable BNR called');
+    let isSuccess = false;
+
+    try {
+      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);
+      const audioStream = MediaUtil.createMediaStream([this.mediaProperties.audioTrack]);
+
+      LoggerProxy.logger.info('Meeting:index#enableBNR. BNR enabled track obtained from WebRTC & sent to updateAudio');
+      await this.updateAudio({
+        sendAudio: true,
+        receiveAudio: true,
+        stream: audioStream
+      });
+      this.isBnrEnabled = true;
+      isSuccess = true;
+    }
+    catch (error) {
+      LoggerProxy.logger.error(`Meeting:index#enableBNR. ${error}`);
+      throw error;
+    }
+
+    return isSuccess;
+  }
+
+  /**
+   * disableBNR API
+   * @returns {Promise<Boolean>}
+   * @public
+   * @memberof Meeting
+   */
+  async disableBNR() {
+    LoggerProxy.logger.info('Meeting:index#disableBNR. Disable BNR called');
+    let isSuccess = false;
+
+    try {
+      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]);
+
+      LoggerProxy.logger.info('Meeting:index#disableBNR. Raw media track obtained from WebRTC & sent to updateAudio');
+      await this.updateAudio({
+        sendAudio: true,
+        receiveAudio: true,
+        stream: audioStream
+      });
+      this.isBnrEnabled = false;
+      isSuccess = true;
+    }
+    catch (error) {
+      LoggerProxy.logger.error(`Meeting:index#disableBNR. ${error}`);
+      throw error;
+    }
+
+    return isSuccess;
+  }
 }

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

@@ -105,6 +105,9 @@ describe('plugin-meetings', () => {
             groupId: '29d9339cc77bffdd24cb69ee80f6d3200481099bcd0f29267558672de0430777',
           }
         ])),
+        getSupportedConstraints: sinon.stub().returns({
+          sampleRate: true
+        })
       },
     });
 
@@ -445,6 +448,170 @@ describe('plugin-meetings', () => {
           });
         });
       });
+      describe('BNR', () => {
+        class FakeMediaStream {
+          constructor() {
+            this.active = false;
+            this.id = '5146425f-c240-48cc-b86b-27d422988fb7';
+          }
+
+          addTrack = () => undefined;
+        }
+
+        class FakeAudioContext {
+          constructor() {
+            this.state = 'running';
+            this.baseLatency = 0.005333333333333333;
+            this.currentTime = 2.7946666666666666;
+            this.sampleRate = 48000;
+            this.audioWorklet = {
+              addModule: async () => undefined,
+            };
+          }
+
+          onstatechange = null;
+
+          createMediaStreamSource() {
+            return {
+              connect: () => undefined,
+              mediaStream: {
+                getAudioTracks() {
+                  // eslint-disable-next-line no-undef
+                  return [new MediaStreamTrack()];
+                },
+              },
+            };
+          }
+
+          createMediaStreamDestination() {
+            return {
+              stream: {
+                getAudioTracks() {
+                  // eslint-disable-next-line no-undef
+                  return [new MediaStreamTrack()];
+                },
+              },
+            };
+          }
+        }
+
+        class FakeAudioWorkletNode {
+          constructor() {
+            this.port = {
+              postMessage: () => undefined,
+            };
+          }
+
+          connect() {
+            /* placeholder method */
+          }
+        }
+
+        class FakeMediaStreamTrack {
+          constructor() {
+            this.kind = 'audio';
+            this.enabled = true;
+            this.label = 'Default - MacBook Pro Microphone (Built-in)';
+            this.muted = false;
+            this.readyState = 'live';
+            this.contentHint = '';
+          }
+        }
+        Object.defineProperty(global, 'MediaStream', {
+          writable: true,
+          value: FakeMediaStream,
+        });
+
+        Object.defineProperty(global, 'AudioContext', {
+          writable: true,
+          value: FakeAudioContext,
+        });
+
+        Object.defineProperty(global, 'AudioWorkletNode', {
+          writable: true,
+          value: FakeAudioWorkletNode,
+        });
+
+        Object.defineProperty(global, 'MediaStreamTrack', {
+          writable: true,
+          value: FakeMediaStreamTrack,
+        });
+
+        beforeEach(async () => {
+          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());
+          });
+          await meeting.getMediaStreams();
+          await meeting.addMedia();
+        });
+
+        describe('#enableBNR', () => {
+          it('should have #enableBnr', () => {
+            assert.exists(meeting.enableBNR);
+          });
+
+          describe('before audio attached to meeting', () => {
+            it('should throw no audio error', async () => {
+              await meeting.enableBNR().catch((err) => {
+                assert.equal(err.toString(), 'Error: Meeting doesn\'t have an audioTrack attached');
+              });
+            });
+          });
+
+          describe('after audio attached to meeting', () => {
+            it('should return true for appropriate sample rate', async () => {
+              const response = await meeting.enableBNR();
+
+              assert.equal(response, true);
+            });
+
+            it('should throw error for inappropriate sample rate', async () => {
+              const fakeMediaTrack = () => ({
+                stop: () => {},
+                readyState: 'live',
+                getSettings: () => ({
+                  sampleRate: 49000
+                })
+              });
+
+              sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack());
+              await meeting.enableBNR().catch((err) => {
+                assert.equal(err.message, 'Sample rate of 49000 is not supported.');
+              });
+            });
+          });
+        });
+
+        describe('#disableBNR', () => {
+          it('should have #disableBnr', () => {
+            assert.exists(meeting.disableBNR);
+          });
+
+          it('should return true if bnr is disabled on bnr enabled track', async () => {
+            const response = await meeting.disableBNR();
+
+            assert.equal(response, true);
+          });
+
+          it('should throw error if bnr is not enabled before disabling', async () => {
+            await meeting.disableBNR().catch((err) => {
+              assert.equal(err.message, 'Can not disable as BNR is not enabled');
+            });
+          });
+        });
+      });
       describe('#muteVideo', () => {
         it('should have #muteVideo', () => {
           assert.exists(meeting.muteVideo);