@webex/plugin-meetings 2.13.0 → 2.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "description": "",
   "license": "MIT",
   "contributors": [
@@ -24,19 +24,19 @@
   },
   "dependencies": {
     "@babel/runtime-corejs2": "^7.14.8",
-    "@webex/webex-core": "2.13.0",
-    "@webex/internal-plugin-mercury": "2.13.0",
-    "@webex/internal-plugin-conversation": "2.13.0",
+    "@webex/webex-core": "2.14.0",
+    "@webex/internal-plugin-mercury": "2.14.0",
+    "@webex/internal-plugin-conversation": "2.14.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.13.0",
+    "@webex/common": "2.14.0",
     "bowser": "^2.11.0",
     "sdp-transform": "^2.12.0",
     "readable-stream": "^3.6.0",
-    "@webex/common-timers": "2.13.0",
+    "@webex/common-timers": "2.14.0",
     "btoa": "^1.2.1",
     "@webex/internal-media-core": "^0.0.6-beta",
     "javascript-state-machine": "^3.1.0",

package/src/meeting/effectsState.js

@@ -0,0 +1,206 @@
+/* eslint-disable no-param-reassign */
+import {Media as WebRTCMedia} from '@webex/internal-media-core';
+
+import BEHAVIORAL_METRICS from '../metrics/constants';
+import Metrics from '../metrics';
+import MediaUtil from '../media/util';
+import LoggerProxy from '../common/logs/logger-proxy';
+import {BNR_STATUS} from '../constants';
+
+const createEffectsState = (type) => {
+  LoggerProxy.logger.info(`Meeting:effectState#createEffectsState --> creating effectsState for effect ${type}`);
+
+  return new EffectsState(type);
+};
+
+/* The purpose of this class is to manage the effects state(for eg., BNR).
+*/
+class EffectsState {
+  constructor(type) {
+    this.effectType = type;
+    this.state = {
+      bnr: {
+        enabled: BNR_STATUS.NOT_ENABLED
+      },
+      callToWebrtcBNRInProgress: false
+    };
+    // these 2 hold the resolve, reject methods for the promise we returned to the client in last handleClientRequest() call
+    this.pendingPromiseResolve = null;
+    this.pendingPromiseReject = null;
+  }
+
+  /**
+   * @memberof EffectsState
+   * @param {Boolean} [isEnable] true for enableBNR, false for disableBNR request
+   * @param {Object} [meeting] the meeting object
+   * @returns {Promise}
+   */
+  async handleClientRequest(isEnable, meeting) {
+    return new Promise((resolve, reject) => {
+      if (this.pendingPromiseResolve) {
+        // resolve the last promise we returned to the client as the client has issued a new request that has superseded the previous one
+        this.pendingPromiseResolve();
+      }
+      this.pendingPromiseResolve = resolve;
+      this.pendingPromiseReject = reject;
+
+      if (isEnable) this.enableBNR(meeting);
+      else this.disableBNR(meeting);
+    });
+  }
+
+  /**
+   * Internal API to return status of BNR
+   * @memberof EffectsState
+   * @returns {Boolean}
+   * @public
+   * @memberof Meeting
+   */
+  isBnrEnabled() {
+    return this.state.bnr.enabled === BNR_STATUS.ENABLED;
+  }
+
+  resolvePromise() {
+    if (this.pendingPromiseResolve) {
+      this.pendingPromiseResolve(true);
+    }
+    this.pendingPromiseResolve = null;
+    this.pendingPromiseReject = null;
+  }
+
+  rejectPromise(e) {
+    if (this.pendingPromiseReject) {
+      this.pendingPromiseReject(e);
+    }
+    this.pendingPromiseResolve = null;
+    this.pendingPromiseReject = null;
+  }
+
+  /**
+   * enableBNR API
+   * @param {Object} meeting the meeting object
+   * @returns {Promise<Boolean>}
+   * @public
+   * @memberof EffectsState
+   */
+  async enableBNR(meeting) {
+    LoggerProxy.logger.info('Meeting:effectState#enableBNR. Enable BNR called');
+
+    if (this.isBnrEnabled()) {
+      LoggerProxy.logger.warn('Meeting:index#enableBNR. BNR is already enabled');
+
+      return this.resolvePromise();
+    }
+
+    if (this.state.callToWebrtcBNRInProgress) {
+      LoggerProxy.logger.warn('Meeting:effectState#enableBNR. Call to WebRTC in progress, we need to wait for it to complete');
+
+      return this.resolvePromise();
+    }
+
+    const {bnr} = this.state;
+
+    try {
+      bnr.enabled = BNR_STATUS.SHOULD_ENABLE;
+      this.state.callToWebrtcBNRInProgress = true;
+      const audioStream = MediaUtil.createMediaStream([meeting.mediaProperties.audioTrack]);
+
+      LoggerProxy.logger.info('Meeting:effectState#enableBNR. MediaStream created from meeting & sent to updateAudio');
+      await meeting.updateAudio({
+        sendAudio: true,
+        receiveAudio: meeting.mediaProperties.mediaDirection.receiveAudio,
+        stream: audioStream,
+        bnrEnabled: bnr.enabled
+      });
+
+      LoggerProxy.logger.info('Meeting:effectState#enableBNR. Updated meeting audio with bnr enabled track');
+      bnr.enabled = BNR_STATUS.ENABLED;
+      this.state.callToWebrtcBNRInProgress = false;
+      Metrics.sendBehavioralMetric(
+        BEHAVIORAL_METRICS.ENABLE_BNR_SUCCESS,
+      );
+    }
+    catch (error) {
+      bnr.enabled = BNR_STATUS.NOT_ENABLED;
+      this.state.callToWebrtcBNRInProgress = false;
+      LoggerProxy.logger.error('Meeting:index#enableBNR.', error);
+
+      Metrics.sendBehavioralMetric(
+        BEHAVIORAL_METRICS.ENABLE_BNR_FAILURE,
+        {
+          reason: error.message,
+          stack: error.stack
+        }
+      );
+      this.rejectPromise(error);
+
+      throw error;
+    }
+
+    return this.resolvePromise();
+  }
+
+  /**
+   * disableBNR API
+   * @param {Object} meeting the meeting object
+   * @returns {Promise<Boolean>}
+   * @public
+   * @memberof EffectsState
+   */
+  async disableBNR(meeting) {
+    LoggerProxy.logger.info('Meeting:effectState#disableBNR. Disable BNR called');
+
+    const {bnr} = this.state;
+
+    try {
+      if (this.state.callToWebrtcBNRInProgress) {
+        LoggerProxy.logger.info('Meeting:effectState#disableBNR. Call to WebRTC in progress, we need to wait for it to complete');
+
+        return this.resolvePromise();
+      }
+
+      bnr.enabled = BNR_STATUS.SHOULD_DISABLE;
+      this.state.callToWebrtcBNRInProgress = true;
+
+      const audioTrack = WebRTCMedia.Effects.BNR.disableBNR(meeting.mediaProperties.audioTrack);
+
+      const audioStream = MediaUtil.createMediaStream([audioTrack]);
+
+      LoggerProxy.logger.info('Meeting:effectState#disableBNR. Raw media track obtained from WebRTC & sent to updateAudio');
+
+      await meeting.updateAudio({
+        sendAudio: true,
+        receiveAudio: meeting.mediaProperties.mediaDirection.receiveAudio,
+        stream: audioStream
+      });
+
+      bnr.enabled = BNR_STATUS.NOT_ENABLED;
+
+      this.state.callToWebrtcBNRInProgress = false;
+
+      Metrics.sendBehavioralMetric(
+        BEHAVIORAL_METRICS.DISABLE_BNR_SUCCESS
+      );
+    }
+    catch (error) {
+      bnr.enabled = BNR_STATUS.ENABLED;
+      this.state.callToWebrtcBNRInProgress = false;
+      LoggerProxy.logger.error(`Meeting:index#disableBNR. ${error}`);
+
+      Metrics.sendBehavioralMetric(
+        BEHAVIORAL_METRICS.DISABLE_BNR_FAILURE,
+        {
+          reason: error.message,
+          stack: error.stack
+        }
+      );
+      this.rejectPromise(error);
+
+      throw error;
+    }
+
+    return this.resolvePromise();
+  }
+}
+
+export default createEffectsState;

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;
@@ -4495,7 +4496,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 +4506,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 +5775,7 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   isBnrEnabled() {
-    return this.bnrStatus === BNR_STATUS.ENABLED;
+    return this.effects && this.effects.isBnrEnabled();
   }
 
   /**
@@ -5797,109 +5801,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, `
+    });
   }
 }