@webex/plugin-meetings 2.13.0 → 2.14.2

package/src/meeting/index.js

@@ -16,6 +16,7 @@ import Media from '../media';
 import MediaProperties from '../media/properties';
 import MeetingStateMachine from '../meeting/state';
 import createMuteState from '../meeting/muteState';
+import createEffectsState from '../meeting/effectsState';
 import LocusInfo from '../locus-info';
 import PeerConnectionManager from '../peer-connection-manager';
 import Metrics from '../metrics';
@@ -531,6 +532,14 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     this.video = null;
+    /**
+     * created later
+     * @instance
+     * @type {EffectsState}
+     * @private
+     * @memberof Meeting
+     */
+    this.effects = null;
     /**
      * @instance
      * @type {MeetingStateMachine}
@@ -915,14 +924,6 @@ 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;
@@ -1592,6 +1593,24 @@ export default class Meeting extends StatelessWebexPlugin {
           {meetingContainerUrl}
         );
       });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_MEETING_TRANSCRIBE_UPDATED,
+      ({caption, transcribing}) => {
+        if (transcribing && this.transcription && this.config.receiveTranscription) {
+          this.receiveTranscription();
+        }
+        else if (!transcribing && this.transcription) {
+          Trigger.trigger(
+            this,
+            {
+              file: 'meeting/index',
+              function: 'setupLocusControlsListener'
+            },
+            EVENT_TRIGGERS.MEETING_STOPPED_RECEIVING_TRANSCRIPTION,
+            {caption, transcribing}
+          );
+        }
+      });
   }
 
   /**
@@ -3396,7 +3415,7 @@ export default class Meeting extends StatelessWebexPlugin {
    * @throws TranscriptionNotSupportedError
    */
   isTranscriptionSupported() {
-    if (this.policy?.WEBEX_ASSISTANT_STATUS_ACTIVE) {
+    if (this.locusInfo.controls.transcribe?.transcribing) {
       return true;
     }
 
@@ -4495,7 +4514,9 @@ export default class Meeting extends StatelessWebexPlugin {
     if (!this.canUpdateMedia()) {
       return this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.AUDIO, options);
     }
-    const {sendAudio, receiveAudio, stream} = options;
+    const {
+      sendAudio, receiveAudio, stream, bnrEnabled
+    } = options;
     const {audioTransceiver} = this.mediaProperties.peerConnection;
     let track = MeetingUtil.getTrack(stream).audioTrack;
 
@@ -4503,9 +4524,10 @@ export default class Meeting extends StatelessWebexPlugin {
       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)) {
+    if (sendAudio && !this.isAudioMuted() && (bnrEnabled === BNR_STATUS.ENABLED || bnrEnabled === BNR_STATUS.SHOULD_ENABLE)) {
+      LoggerProxy.logger.info('Meeting:index#updateAudio. Calling WebRTC enable bnr method');
       track = await this.internal_enableBNR(track);
-      this.bnrStatus = BNR_STATUS.ENABLED;
+      LoggerProxy.logger.info('Meeting:index#updateAudio. WebRTC enable bnr request completed');
     }
 
     return MeetingUtil.validateOptions({sendAudio, localStream: stream})
@@ -5771,7 +5793,7 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   isBnrEnabled() {
-    return this.bnrStatus === BNR_STATUS.ENABLED;
+    return this.effects && this.effects.isBnrEnabled();
   }
 
   /**
@@ -5797,109 +5819,72 @@ export default class Meeting extends StatelessWebexPlugin {
   }
 
   /**
-   * enableBNR API
-   * @returns {Promise<Boolean>}
+   * Enable the audio track with BNR for a meeting
+   * @returns {Promise} resolves the data from enable bnr or rejects if there is no audio or audio is muted
    * @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");
-      }
-      else if (this.isAudioMuted()) {
-        throw new Error('Cannot enable BNR while meeting is muted');
-      }
+  enableBNR() {
+    if (typeof this.mediaProperties === 'undefined' || typeof this.mediaProperties.audioTrack === 'undefined') {
+      return Promise.reject(new Error("Meeting doesn't have an audioTrack attached"));
+    }
 
+    if (this.isAudioMuted()) {
+      return Promise.reject(new Error('Cannot enable BNR while meeting is muted'));
+    }
 
-      this.bnrStatus = BNR_STATUS.SHOULD_ENABLE;
+    this.effects = this.effects || createEffectsState('BNR');
 
-      const audioStream = MediaUtil.createMediaStream([this.mediaProperties.audioTrack]);
+    const LOG_HEADER = 'Meeting:index#enableBNR -->';
 
-      LoggerProxy.logger.info('Meeting:index#enableBNR. MediaStream created from meeting & sent to updateAudio');
-      await this.updateAudio({
-        sendAudio: true,
-        receiveAudio: this.mediaProperties.mediaDirection.receiveAudio,
-        stream: audioStream
-      });
-      this.bnrStatus = BNR_STATUS.ENABLED;
-      isSuccess = true;
-      Metrics.sendBehavioralMetric(
-        BEHAVIORAL_METRICS.ENABLE_BNR_SUCCESS,
-      );
-    }
-    catch (error) {
-      this.bnrStatus = BNR_STATUS.NOT_ENABLED;
-      Metrics.sendBehavioralMetric(
-        BEHAVIORAL_METRICS.ENABLE_BNR_FAILURE,
-        {
-          reason: error.message,
-          stack: error.stack
-        }
-      );
-      LoggerProxy.logger.error('Meeting:index#enableBNR.', error);
-      throw error;
-    }
+    return logRequest(this.effects.handleClientRequest(true, this)
+      .then((res) => {
+        LoggerProxy.logger.info('Meeting:index#enableBNR. Enable bnr completed');
 
-    return isSuccess;
+        return res;
+      })
+      .catch((error) => {
+        throw error;
+      }),
+    {
+      header: `${LOG_HEADER} enable bnr`,
+      success: `${LOG_HEADER} enable bnr success`,
+      failure: `${LOG_HEADER} enable bnr failure, `
+    });
   }
 
   /**
-   * disableBNR API
-   * @returns {Promise<Boolean>}
+   * Disable the BNR for an audio track
+   * @returns {Promise} resolves the data from disable bnr or rejects if there is no audio set
    * @public
    * @memberof Meeting
    */
-  async disableBNR() {
-    LoggerProxy.logger.info('Meeting:index#disableBNR. Disable BNR called');
-    let isSuccess = false;
-
-    try {
-      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");
-      }
-      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: this.mediaProperties.mediaDirection.receiveAudio,
-        stream: audioStream
-      });
-
-      this.bnrStatus = BNR_STATUS.NOT_ENABLED;
-
-      isSuccess = true;
+  disableBNR() {
+    if (typeof this.mediaProperties === 'undefined' || typeof this.mediaProperties.audioTrack === 'undefined') {
+      return Promise.reject(new Error("Meeting doesn't have an audioTrack attached"));
+    }
 
-      Metrics.sendBehavioralMetric(
-        BEHAVIORAL_METRICS.DISABLE_BNR_SUCCESS
-      );
+    if (!this.isBnrEnabled()) {
+      return Promise.reject(new Error('Can not disable as BNR is not enabled'));
     }
-    catch (error) {
-      this.bnrStatus = BNR_STATUS.ENABLED;
-      LoggerProxy.logger.error(`Meeting:index#disableBNR. ${error}`);
 
-      Metrics.sendBehavioralMetric(
-        BEHAVIORAL_METRICS.DISABLE_BNR_FAILURE,
-        {
-          reason: error.message,
-          stack: error.stack
-        }
-      );
+    this.effects = this.effects || createEffectsState('BNR');
 
-      throw error;
-    }
+    const LOG_HEADER = 'Meeting:index#disableBNR -->';
+
+    return logRequest(this.effects.handleClientRequest(false, this)
+      .then((res) => {
+        LoggerProxy.logger.info('Meeting:index#disableBNR. Disable bnr completed');
 
-    return isSuccess;
+        return res;
+      })
+      .catch((error) => {
+        throw error;
+      }),
+    {
+      header: `${LOG_HEADER} disable bnr`,
+      success: `${LOG_HEADER} disable bnr success`,
+      failure: `${LOG_HEADER} disable bnr failure, `
+    });
   }
 }

package/src/meeting-info/meeting-info-v2.js

@@ -151,10 +151,7 @@ export default class MeetingInfoV2 {
           method: HTTP_VERBS.POST,
           uri,
           body
-        })
-          .catch((err) => {
-            throw new MeetingInfoV2AdhocMeetingError(err.body?.code, err.body?.message);
-          });
+        });
       })
       .catch((err) => {
         Metrics.sendBehavioralMetric(

package/test/unit/spec/locus-info/index.js

@@ -255,6 +255,40 @@ describe('plugin-meetings', () => {
         });
       });
 
+      it('should update the transcript state', () => {
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.controls = {
+          lock: {},
+          meetingFull: {},
+          record: {
+            recording: false,
+            paused: true,
+            meta: {
+              lastModified: 'TODAY',
+              modifiedBy: 'George Kittle'
+            }
+          },
+          shareControl: {},
+          transcribe: {
+            transcribing: false,
+            caption: false
+          }
+        };
+        newControls.transcribe.transcribing = true;
+        newControls.transcribe.caption = true;
+
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(locusInfo.emitScoped, {
+          file: 'locus-info',
+          function: 'updateControls'
+        },
+        LOCUSINFO.EVENTS.CONTROLS_MEETING_TRANSCRIBE_UPDATED,
+        {
+          transcribing: true, caption: true
+        });
+      });
+
       it('should update the meetingContainerURL from null', () => {
         locusInfo.controls = {
           meetingContainer: {meetingContainerUrl: null},

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

@@ -0,0 +1,292 @@
+/* eslint-disable camelcase */
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import MockWebex from '@webex/test-helper-mock-webex';
+
+import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
+import {BNR_STATUS} from '@webex/plugin-meetings/src/constants';
+import Meeting from '@webex/plugin-meetings/src/meeting';
+import Meetings from '@webex/plugin-meetings';
+import Metrics from '@webex/plugin-meetings/src/metrics';
+import MediaUtil from '@webex/plugin-meetings/src/media/util';
+import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
+import createEffectsState from '@webex/plugin-meetings/src/meeting/effectsState';
+import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
+import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
+
+describe('plugin-meetings', () => {
+  const logger = {
+    info: () => {},
+    log: () => {},
+    error: () => {},
+    warn: () => {},
+    trace: () => {},
+    debug: () => {}
+  };
+
+  beforeEach(() => {
+    sinon.stub(Metrics, 'sendBehavioralMetric');
+  });
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  Object.defineProperty(global.window.navigator, 'mediaDevices', {
+    writable: true,
+    value: {
+      getSupportedConstraints: sinon.stub().returns({
+        sampleRate: true
+      })
+    },
+  });
+  LoggerConfig.set({verboseEvents: true, enable: false});
+  LoggerProxy.set(logger);
+
+  let webex;
+  let meeting;
+  let uuid1;
+
+  const fakeMediaTrack = () => ({
+    id: Date.now().toString(),
+    stop: () => {},
+    readyState: 'live',
+    enabled: true,
+    getSettings: () => ({
+      sampleRate: 48000
+    })
+  });
+
+  class FakeMediaStream {
+    constructor(tracks) {
+      this.active = false;
+      this.id = '5146425f-c240-48cc-b86b-27d422988fb7';
+      this.tracks = tracks;
+    }
+
+    addTrack = () => undefined;
+
+    getAudioTracks = () => this.tracks;
+  }
+
+  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 = '';
+    }
+
+    getSettings() {
+      return {
+        sampleRate: 48000
+      };
+    }
+  }
+  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,
+  });
+
+  let effects;
+
+  beforeEach(() => {
+    webex = new MockWebex({
+      children: {
+        meetings: Meetings
+      }
+    });
+    MediaUtil.createPeerConnection = sinon.stub().returns({});
+    meeting = new Meeting(
+      {
+        userId: uuid1
+      },
+      {
+        parent: webex
+      }
+    );
+
+    effects = createEffectsState('BNR');
+    meeting.canUpdateMedia = sinon.stub().returns(true);
+    MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve());
+    MeetingUtil.updateTransceiver = sinon.stub();
+
+    meeting.addMedia = sinon.stub().returns(Promise.resolve());
+    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
+      });
+    });
+  });
+
+  describe('bnr effect library', () => {
+    beforeEach(async () => {
+      await meeting.getMediaStreams();
+      await meeting.addMedia();
+    });
+    describe('#enableBNR', () => {
+      it('should have #enableBnr', () => {
+        assert.exists(effects.enableBNR);
+      });
+
+      it('does bnr effect enable on audio track', async () => {
+        assert.isTrue(await effects.handleClientRequest(true, meeting));
+        assert.equal(effects.state.bnr.enabled, BNR_STATUS.ENABLED);
+
+        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          BEHAVIORAL_METRICS.ENABLE_BNR_SUCCESS,
+        );
+      });
+
+      it('does resolve request if bnr is already enabled', async () => {
+        effects.state.bnr.enabled = BNR_STATUS.ENABLED;
+        assert.isTrue(await effects.handleClientRequest(true, meeting));
+        assert.equal(effects.state.bnr.enabled, BNR_STATUS.ENABLED);
+      });
+
+      it('if called twice, does bnr effect enable on audio track for the first request and resolves second', async () => {
+        Promise.all([effects.handleClientRequest(true, meeting), effects.handleClientRequest(true, meeting)])
+          .then((resolveFirst, resolveSecond) => {
+            assert.isTrue(resolveFirst);
+            assert.isTrue(resolveSecond);
+            assert.calledOnce(MediaUtil.createMediaStream);
+          });
+      });
+
+      it('should throw error for inappropriate sample rate and send error metrics', async () => {
+        const fakeMediaTrack1 = () => ({
+          id: Date.now().toString(),
+          stop: () => {},
+          readyState: 'live',
+          getSettings: () => ({
+            sampleRate: 49000
+          })
+        });
+
+        sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack1());
+
+        // eslint-disable-next-line no-undef
+        MediaUtil.createMediaStream = sinon.stub().returns(new MediaStream([fakeMediaTrack1()]));
+        try {
+          await effects.handleClientRequest(true, meeting);
+        }
+        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(() => {
+        effects.state.bnr.enabled = BNR_STATUS.ENABLED;
+      });
+      it('should have #disableBnr', () => {
+        assert.exists(effects.disableBNR);
+      });
+
+      it('does bnr disable on audio track', async () => {
+        assert.isTrue(await effects.handleClientRequest(false, meeting));
+        assert.equal(effects.state.bnr.enabled, BNR_STATUS.NOT_ENABLED);
+
+        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          BEHAVIORAL_METRICS.DISABLE_BNR_SUCCESS,
+        );
+      });
+
+      it('reject request for disable bnr if not enabled', async () => {
+        try {
+          await effects.handleClientRequest(false, meeting);
+        }
+        catch (e) {
+          assert.equal(e.message, 'Can not disable as BNR is not enabled');
+          assert.equal(effects.state.bnr.enabled, BNR_STATUS.ENABLED);
+
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.DISABLE_BNR_FAILURE,
+          );
+        }
+      });
+    });
+  });
+});