@webex/plugin-meetings 3.7.0-next.56 → 3.7.0-next.58

package/dist/types/meeting/brbState.d.ts

@@ -0,0 +1,54 @@
+import type Meeting from '.';
+import SendSlotManager from '../multistream/sendSlotManager';
+export declare const createBrbState: (meeting: Meeting, enabled: boolean) => BrbState;
+/** The purpose of this class is to manage the local and remote brb state
+ * and make sure that the server state always matches the last requested state by the client.
+ */
+export declare class BrbState {
+    state: {
+        client: {
+            enabled: boolean;
+        };
+        server: {
+            enabled: boolean;
+        };
+        syncToServerInProgress: boolean;
+    };
+    meeting: Meeting;
+    /**
+     * Constructor
+     *
+     * @param {Meeting} meeting - the meeting object
+     * @param {boolean} enabled - whether the client audio/video is enabled at all
+     */
+    constructor(meeting: Meeting, enabled: boolean);
+    /**
+     * Enables/disables brb
+     *
+     * @param {boolean} enabled
+     * @param {SendSlotManager} sendSlotManager
+     * @returns {Promise}
+     */
+    enable(enabled: boolean, sendSlotManager: SendSlotManager): Promise<void>;
+    /**
+     * Updates the server local and remote brb values so that they match the current client desired state.
+     *
+     * @param {SendSlotManager} sendSlotManager
+     * @returns {Promise}
+     */
+    private applyClientStateToServer;
+    /**
+     * Send the local brb state to the server
+     *
+     * @param {SendSlotManager} sendSlotManager
+     * @returns {Promise}
+     */
+    private sendLocalBrbStateToServer;
+    /**
+     * This method should be called whenever the server brb state is changed
+     *
+     * @param {Boolean} [enabled] true if user has brb enabled, false otherwise
+     * @returns {undefined}
+     */
+    handleServerBrbUpdate(enabled?: boolean): void;
+}

package/dist/types/meeting/index.d.ts

@@ -19,6 +19,7 @@ import InMeetingActions from './in-meeting-actions';
 import RecordingController from '../recording-controller';
 import ControlsOptionsManager from '../controls-options-manager';
 import { LocusMediaRequest } from './locusMediaRequest';
+import { BrbState } from './brbState';
 export type CaptionData = {
     id: string;
     isFinal: boolean;
@@ -449,6 +450,7 @@ export default class Meeting extends StatelessWebexPlugin {
     turnServerUsed: boolean;
     areVoiceaEventsSetup: boolean;
     isMoveToInProgress: boolean;
+    brbState: BrbState;
     voiceaListenerCallbacks: object;
     private addMediaData;
     private sendSlotManager;

package/dist/webinar/index.js

@@ -458,7 +458,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
       }, _callee7);
     }))();
   },
-  version: "3.7.0-next.56"
+  version: "3.7.0-next.58"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -43,7 +43,7 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/plugin-meetings": "3.7.0-next.56",
+    "@webex/plugin-meetings": "3.7.0-next.58",
     "@webex/plugin-rooms": "3.7.0-next.22",
     "@webex/test-helper-chai": "3.7.0-next.16",
     "@webex/test-helper-mocha": "3.7.0-next.16",
@@ -71,7 +71,7 @@
     "@webex/internal-plugin-metrics": "3.7.0-next.16",
     "@webex/internal-plugin-support": "3.7.0-next.23",
     "@webex/internal-plugin-user": "3.7.0-next.16",
-    "@webex/internal-plugin-voicea": "3.7.0-next.56",
+    "@webex/internal-plugin-voicea": "3.7.0-next.58",
     "@webex/media-helpers": "3.7.0-next.22",
     "@webex/plugin-people": "3.7.0-next.20",
     "@webex/plugin-rooms": "3.7.0-next.22",
@@ -92,5 +92,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.7.0-next.56"
+  "version": "3.7.0-next.58"
 }

package/src/meeting/brbState.ts

@@ -0,0 +1,169 @@
+import {MediaType} from '@webex/internal-media-core';
+import LoggerProxy from '../common/logs/logger-proxy';
+import type Meeting from '.';
+import SendSlotManager from '../multistream/sendSlotManager';
+
+export const createBrbState = (meeting: Meeting, enabled: boolean) => {
+  LoggerProxy.logger.info(
+    `Meeting:brbState#createBrbState: creating BrbState for meeting id ${meeting?.id}`
+  );
+
+  const brbState = new BrbState(meeting, enabled);
+
+  return brbState;
+};
+
+/** The purpose of this class is to manage the local and remote brb state
+ * and make sure that the server state always matches the last requested state by the client.
+ */
+export class BrbState {
+  state: {
+    client: {
+      enabled: boolean;
+    };
+    server: {
+      enabled: boolean;
+    };
+    syncToServerInProgress: boolean;
+  };
+
+  meeting: Meeting;
+
+  /**
+   * Constructor
+   *
+   * @param {Meeting} meeting - the meeting object
+   * @param {boolean} enabled - whether the client audio/video is enabled at all
+   */
+  constructor(meeting: Meeting, enabled: boolean) {
+    this.meeting = meeting;
+    this.state = {
+      client: {
+        enabled,
+      },
+      server: {
+        enabled: false,
+      },
+      syncToServerInProgress: false,
+    };
+  }
+
+  /**
+   * Enables/disables brb
+   *
+   * @param {boolean} enabled
+   * @param {SendSlotManager} sendSlotManager
+   * @returns {Promise}
+   */
+  public enable(enabled: boolean, sendSlotManager: SendSlotManager) {
+    this.state.client.enabled = enabled;
+
+    return this.applyClientStateToServer(sendSlotManager);
+  }
+
+  /**
+   * Updates the server local and remote brb values so that they match the current client desired state.
+   *
+   * @param {SendSlotManager} sendSlotManager
+   * @returns {Promise}
+   */
+  private applyClientStateToServer(sendSlotManager: SendSlotManager) {
+    if (this.state.syncToServerInProgress) {
+      LoggerProxy.logger.info(
+        `Meeting:brbState#applyClientStateToServer: request to server in progress, we need to wait for it to complete`
+      );
+
+      return Promise.resolve();
+    }
+
+    const remoteBrbRequiresSync = this.state.client.enabled !== this.state.server.enabled;
+
+    LoggerProxy.logger.info(
+      `Meeting:brbState#applyClientStateToServer: remoteBrbRequiresSync: ${remoteBrbRequiresSync}`
+    );
+
+    if (!remoteBrbRequiresSync) {
+      LoggerProxy.logger.info(
+        `Meeting:brbState#applyClientStateToServer: client state already matching server state, nothing to do`
+      );
+
+      return Promise.resolve();
+    }
+
+    this.state.syncToServerInProgress = true;
+
+    return this.sendLocalBrbStateToServer(sendSlotManager)
+      .then(() => {
+        this.state.syncToServerInProgress = false;
+        LoggerProxy.logger.info(
+          `Meeting:brbState#applyClientStateToServer: sync with server completed`
+        );
+
+        // need to check if a new sync is required, because this.state.client may have changed while we were doing the current sync
+        this.applyClientStateToServer(sendSlotManager);
+      })
+      .catch((e) => {
+        this.state.syncToServerInProgress = false;
+        LoggerProxy.logger.warn(`Meeting:brbState#applyClientStateToServer: error: ${e}`);
+      });
+  }
+
+  /**
+   * Send the local brb state to the server
+   *
+   * @param {SendSlotManager} sendSlotManager
+   * @returns {Promise}
+   */
+  private async sendLocalBrbStateToServer(sendSlotManager: SendSlotManager) {
+    const {enabled} = this.state.client;
+
+    if (!this.meeting.isMultistream) {
+      const errorMessage = 'Meeting:brbState#sendLocalBrbStateToServer: Not a multistream meeting';
+      const error = new Error(errorMessage);
+
+      LoggerProxy.logger.error(error);
+
+      return Promise.reject(error);
+    }
+
+    if (!this.meeting.mediaProperties.webrtcMediaConnection) {
+      const errorMessage =
+        'Meeting:brbState#sendLocalBrbStateToServer: WebRTC media connection is not defined';
+      const error = new Error(errorMessage);
+
+      LoggerProxy.logger.error(error);
+
+      return Promise.reject(error);
+    }
+
+    // this logic should be applied only to multistream meetings
+    return this.meeting.meetingRequest
+      .setBrb({
+        enabled,
+        locusUrl: this.meeting.locusUrl,
+        deviceUrl: this.meeting.deviceUrl,
+        selfId: this.meeting.selfId,
+      })
+      .then(() => {
+        sendSlotManager.setSourceStateOverride(MediaType.VideoMain, enabled ? 'away' : null);
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error('Meeting:brbState#sendLocalBrbStateToServer: Error ', error);
+
+        return Promise.reject(error);
+      });
+  }
+
+  /**
+   * This method should be called whenever the server brb state is changed
+   *
+   * @param {Boolean} [enabled] true if user has brb enabled, false otherwise
+   * @returns {undefined}
+   */
+  public handleServerBrbUpdate(enabled?: boolean) {
+    LoggerProxy.logger.info(
+      `Meeting:brbState#handleServerBrbUpdate: updating server brb to (${enabled})`
+    );
+    this.state.server.enabled = !!enabled;
+  }
+}

package/src/meeting/index.ts

@@ -163,6 +163,7 @@ import {LocusMediaRequest} from './locusMediaRequest';
 import {ConnectionStateHandler, ConnectionStateEvent} from './connectionStateHandler';
 import JoinWebinarError from '../common/errors/join-webinar-error';
 import Member from '../member';
+import {BrbState, createBrbState} from './brbState';
 import MultistreamNotSupportedError from '../common/errors/multistream-not-supported-error';
 import JoinForbiddenError from '../common/errors/join-forbidden-error';
 
@@ -649,6 +650,7 @@ export default class Meeting extends StatelessWebexPlugin {
   turnServerUsed: boolean;
   areVoiceaEventsSetup = false;
   isMoveToInProgress = false;
+  brbState: BrbState;
 
   voiceaListenerCallbacks: object = {
     [VOICEAEVENTS.VOICEA_ANNOUNCEMENT]: (payload: Transcription['languageOptions']) => {
@@ -3407,6 +3409,7 @@ export default class Meeting extends StatelessWebexPlugin {
     });
 
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED, (payload) => {
+      this.brbState?.handleServerBrbUpdate(payload?.brb?.enabled);
       Trigger.trigger(
         this,
         {
@@ -3650,22 +3653,7 @@ export default class Meeting extends StatelessWebexPlugin {
       return Promise.reject(error);
     }
 
-    // this logic should be applied only to multistream meetings
-    return this.meetingRequest
-      .setBrb({
-        enabled,
-        locusUrl: this.locusUrl,
-        deviceUrl: this.deviceUrl,
-        selfId: this.selfId,
-      })
-      .then(() => {
-        this.sendSlotManager.setSourceStateOverride(MediaType.VideoMain, enabled ? 'away' : null);
-      })
-      .catch((error) => {
-        LoggerProxy.logger.error('Meeting:index#beRightBack --> Error ', error);
-
-        return Promise.reject(error);
-      });
+    return this.brbState.enable(enabled, this.sendSlotManager);
   }
 
   /**
@@ -6099,9 +6087,12 @@ export default class Meeting extends StatelessWebexPlugin {
    * @returns {undefined}
    */
   public roapMessageReceived = (roapMessage: RoapMessage) => {
-    const mediaServer = MeetingsUtil.getMediaServer(roapMessage.sdp);
+    const mediaServer =
+      roapMessage.messageType === 'ANSWER'
+        ? MeetingsUtil.getMediaServer(roapMessage.sdp)
+        : undefined;
 
-    if (this.isMultistream && mediaServer !== 'homer') {
+    if (this.isMultistream && mediaServer && mediaServer !== 'homer') {
       throw new MultistreamNotSupportedError(
         `Client asked for multistream backend (Homer), but got ${mediaServer} instead`
       );
@@ -7432,6 +7423,7 @@ export default class Meeting extends StatelessWebexPlugin {
 
     this.audio = createMuteState(AUDIO, this, audioEnabled);
     this.video = createMuteState(VIDEO, this, videoEnabled);
+    this.brbState = createBrbState(this, false);
 
     try {
       await this.setUpLocalStreamReferences(localStreams);

package/test/unit/spec/meeting/brbState.ts

@@ -0,0 +1,114 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+
+import testUtils from '../../../utils/testUtils';
+import {BrbState, createBrbState} from '@webex/plugin-meetings/src/meeting/brbState';
+
+describe('plugin-meetings', () => {
+  let meeting: any;
+  let brbState: BrbState;
+
+  beforeEach(async () => {
+    meeting = {
+      isMultistream: true,
+      locusUrl: 'locus url',
+      deviceUrl: 'device url',
+      selfId: 'self id',
+      mediaProperties: {
+        webrtcMediaConnection: true,
+      },
+      sendSlotManager: {
+        setSourceStateOverride: sinon.stub(),
+      },
+      meetingRequest: {
+        setBrb: sinon.stub().resolves(),
+      },
+    };
+
+    brbState = new BrbState(meeting, false);
+    await testUtils.flushPromises();
+  });
+
+  describe('brbState library', () => {
+    it('takes into account current status when instantiated', async () => {
+      // create a new BrbState instance
+      brbState = createBrbState(meeting, true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(brbState.state.client.enabled);
+
+      // now check the opposite case
+      brbState = createBrbState(meeting, false);
+      await testUtils.flushPromises();
+
+      assert.isFalse(brbState.state.client.enabled);
+    });
+
+    it('can be enabled', async () => {
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(brbState.state.client.enabled);
+      assert.isTrue(brbState.state.server.enabled);
+    });
+
+    it('can be disabled', async () => {
+      brbState.enable(false, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(false);
+      await testUtils.flushPromises();
+
+      assert.isFalse(brbState.state.client.enabled);
+      assert.isFalse(brbState.state.server.enabled);
+    });
+
+    it('does not send local brb state to server if it is not a multistream meeting', async () => {
+      meeting.isMultistream = false;
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.notCalled);
+    });
+
+    it('does not send local brb state to server if webrtc media connection is not defined', async () => {
+      meeting.mediaProperties.webrtcMediaConnection = undefined;
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.notCalled);
+    });
+
+    it('does not send request twice when in progress', async () => {
+      brbState.state.syncToServerInProgress = true;
+      brbState.enable(true, meeting.sendSlotManager);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.notCalled);
+    });
+
+    it('syncs with server when client state does not match server state', async () => {
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.calledOnce);
+    });
+
+    it('sets source state override when client state does not match server state', async () => {
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.sendSlotManager.setSourceStateOverride.calledOnce);
+    });
+
+    it('handles server update', async () => {
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(brbState.state.server.enabled);
+    });
+  });
+});

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

@@ -114,6 +114,7 @@ import {ERROR_DESCRIPTIONS} from '@webex/internal-plugin-metrics/src/call-diagno
 import MeetingCollection from '@webex/plugin-meetings/src/meetings/collection';
 
 import {EVENT_TRIGGERS as VOICEAEVENTS} from '@webex/internal-plugin-voicea';
+import { createBrbState } from '@webex/plugin-meetings/src/meeting/brbState';
 import JoinForbiddenError               from '../../../../src/common/errors/join-forbidden-error';
 
 describe('plugin-meetings', () => {
@@ -3812,7 +3813,6 @@ describe('plugin-meetings', () => {
         };
 
         beforeEach(() => {
-          meeting.meetingRequest.setBrb = sinon.stub().resolves({body: 'test'});
           meeting.mediaProperties.webrtcMediaConnection = {createSendSlot: sinon.stub()};
           meeting.sendSlotManager.createSlot(
             fakeMultistreamRoapMediaConnection,
@@ -3822,6 +3822,8 @@ describe('plugin-meetings', () => {
           meeting.locusUrl = 'locus url';
           meeting.deviceUrl = 'device url';
           meeting.selfId = 'self id';
+          meeting.brbState = createBrbState(meeting, false);
+          meeting.brbState.enable = sinon.stub().resolves();
         });
 
         afterEach(() => {
@@ -3843,7 +3845,7 @@ describe('plugin-meetings', () => {
 
             await brbResult;
             assert.exists(brbResult.then);
-            assert.calledOnce(meeting.meetingRequest.setBrb);
+            assert.calledOnce(meeting.brbState.enable);
           })
 
           it('should disable #beRightBack and return a promise', async () => {
@@ -3851,12 +3853,12 @@ describe('plugin-meetings', () => {
 
             await brbResult;
             assert.exists(brbResult.then);
-            assert.calledOnce(meeting.meetingRequest.setBrb);
+            assert.calledOnce(meeting.brbState.enable);
           })
 
           it('should throw an error and reject the promise if setBrb fails', async () => {
             const error = new Error('setBrb failed');
-            meeting.meetingRequest.setBrb.rejects(error);
+            meeting.brbState.enable.rejects(error);
 
             try {
               await meeting.beRightBack(true);
@@ -3867,27 +3869,6 @@ describe('plugin-meetings', () => {
             }
           })
         });
-
-        describe('when in a transcoded meeting', () => {
-
-          beforeEach(() => {
-            meeting.isMultistream = false;
-          });
-
-          it('should ignore enabling #beRightBack', async () => {
-            meeting.beRightBack(true);
-
-            assert.isRejected((Promise.reject()));
-            assert.notCalled(meeting.meetingRequest.setBrb);
-          })
-
-          it('should ignore disabling #beRightBack', async () => {
-            meeting.beRightBack(false);
-
-            assert.isRejected((Promise.reject()));
-            assert.notCalled(meeting.meetingRequest.setBrb);
-          })
-        });
       });
 
       /* This set of tests are like semi-integration tests, they use real MuteState, Media, LocusMediaRequest and Roap classes.
@@ -9230,6 +9211,7 @@ describe('plugin-meetings', () => {
 
         it('listens to the brb state changed event', () => {
           const assertBrb = (enabled) => {
+            meeting.brbState = createBrbState(meeting, false);
             meeting.locusInfo.emit(
               { function: 'test', file: 'test' },
               LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,
@@ -13260,7 +13242,7 @@ describe('plugin-meetings', () => {
 
   describe('#roapMessageReceived', () => {
     it('calls roapMessageReceived on the webrtc media connection', () => {
-      const fakeMessage = {messageType: 'fake', sdp: 'fake sdp'};
+      const fakeMessage = {messageType: 'ANSWER', sdp: 'fake sdp'};
 
       const getMediaServer = sinon.stub(MeetingsUtil, 'getMediaServer').returns('homer');
 
@@ -13298,5 +13280,26 @@ describe('plugin-meetings', () => {
 
       assert.notCalled(meeting.mediaProperties.webrtcMediaConnection.roapMessageReceived);
     });
+
+    it('does not call getMediaServer for a roap message other than ANSWER', async () => {
+      const fakeMessage = {messageType: 'ERROR', sdp: 'fake sdp'};
+
+      meeting.isMultistream = true;
+      meeting.mediaProperties.webrtcMediaConnection = {
+        roapMessageReceived: sinon.stub(),
+      };
+      meeting.mediaProperties.webrtcMediaConnection.mediaServer = 'linus';
+
+      const getMediaServerStub = sinon.stub(MeetingsUtil, 'getMediaServer').returns('something');
+
+      meeting.roapMessageReceived(fakeMessage);
+
+      assert.calledOnceWithExactly(
+        meeting.mediaProperties.webrtcMediaConnection.roapMessageReceived,
+        fakeMessage
+      );
+      assert.notCalled(getMediaServerStub);
+      assert.equal(meeting.mediaProperties.webrtcMediaConnection.mediaServer, 'linus'); // check that it hasn't been overwritten
+    });
   });
 });