@webex/plugin-meetings 3.7.0-next.3 → 3.7.0-next.31

package/src/recording-controller/index.ts

@@ -1,9 +1,9 @@
 import PermissionError from '../common/errors/permission';
+import LoggerProxy from '../common/logs/logger-proxy';
 import {CONTROLS, HTTP_VERBS, SELF_POLICY} from '../constants';
 import MeetingRequest from '../meeting/request';
-import RecordingAction from './enums';
+import {RecordingAction, RecordingType} from './enums';
 import Util from './util';
-import LoggerProxy from '../common/logs/logger-proxy';
 
 /**
  * @description Recording manages the recording functionality of the meeting object, there should only be one instantation of recording per meeting
@@ -228,11 +228,12 @@ export default class RecordingController {
 
   /**
    * @param {RecordingAction} action
+   * @param {RecordingType} recordingType
    * @private
    * @memberof RecordingController
    * @returns {Promise}
    */
-  private recordingService(action: RecordingAction): Promise<any> {
+  private recordingService(action: RecordingAction, recordingType: RecordingType): Promise<any> {
     // @ts-ignore
     return this.request.request({
       body: {
@@ -242,6 +243,7 @@ export default class RecordingController {
         recording: {
           action: action.toLowerCase(),
         },
+        recordingType,
       },
       uri: `${this.serviceUrl}/loci/${this.locusId}/recording`,
       method: HTTP_VERBS.PUT,
@@ -276,14 +278,25 @@ export default class RecordingController {
    * @returns {Promise}
    */
   private recordingFacade(action: RecordingAction): Promise<any> {
+    const isPremiseRecordingEnabled = Util.isPremiseRecordingEnabled(
+      this.displayHints,
+      this.selfUserPolicies
+    );
     LoggerProxy.logger.log(
       `RecordingController:index#recordingFacade --> recording action [${action}]`
     );
 
+    let recordingType: RecordingType;
+    if (isPremiseRecordingEnabled) {
+      recordingType = RecordingType.Premise;
+    } else {
+      recordingType = RecordingType.Cloud;
+    }
+
     // assumes action is proper cased (i.e., Example)
     if (Util?.[`canUser${action}`](this.displayHints, this.selfUserPolicies)) {
       if (this.serviceUrl) {
-        return this.recordingService(action);
+        return this.recordingService(action, recordingType);
       }
 
       return this.recordingControls(action);

package/src/recording-controller/util.ts

@@ -1,33 +1,47 @@
 import {DISPLAY_HINTS, SELF_POLICY} from '../constants';
-import RecordingAction from './enums';
+import {RecordingAction} from './enums';
 import MeetingUtil from '../meeting/util';
 
 const canUserStart = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_START)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const canUserPause = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const canUserResume = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const canUserStop = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP)) &&
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+
+const isPremiseRecordingEnabled = (
+  displayHints: Array<string>,
+  userPolicies: Record<SELF_POLICY, boolean>
+): boolean =>
+  (displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_START) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const extractLocusId = (url: string) => {
@@ -70,6 +84,7 @@ export default {
   canUserPause,
   canUserResume,
   canUserStop,
+  isPremiseRecordingEnabled,
   deriveRecordingStates,
   extractLocusId,
 };

package/src/webinar/index.ts

@@ -1,11 +1,13 @@
 /*!
  * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
  */
-import {WebexPlugin} from '@webex/webex-core';
+import {WebexPlugin, config} from '@webex/webex-core';
+import uuid from 'uuid';
 import {get} from 'lodash';
-import {MEETINGS, SELF_ROLES} from '../constants';
+import {_ID_, HEADERS, HTTP_VERBS, MEETINGS, SELF_ROLES, SHARE_STATUS} from '../constants';
 
 import WebinarCollection from './collection';
+import LoggerProxy from '../common/logs/logger-proxy';
 
 /**
  * @class Webinar
@@ -22,6 +24,8 @@ const Webinar = WebexPlugin.extend({
     canManageWebcast: 'boolean', // appears the ability to manage webcast
     selfIsPanelist: 'boolean', // self is panelist
     selfIsAttendee: 'boolean', // self is attendee
+    practiceSessionEnabled: 'boolean', // practice session enabled
+    meetingId: 'string',
   },
 
   /**
@@ -59,18 +63,240 @@ const Webinar = WebexPlugin.extend({
    * @returns {{isPromoted: boolean, isDemoted: boolean}} Role transition states
    */
   updateRoleChanged(payload) {
+    const oldRoles = get(payload, 'oldRoles', []);
+    const newRoles = get(payload, 'newRoles', []);
+
     const isPromoted =
-      get(payload, 'oldRoles', []).includes(SELF_ROLES.ATTENDEE) &&
-      get(payload, 'newRoles', []).includes(SELF_ROLES.PANELIST);
+      oldRoles.includes(SELF_ROLES.ATTENDEE) && newRoles.includes(SELF_ROLES.PANELIST);
     const isDemoted =
-      get(payload, 'oldRoles', []).includes(SELF_ROLES.PANELIST) &&
-      get(payload, 'newRoles', []).includes(SELF_ROLES.ATTENDEE);
-    this.set('selfIsPanelist', get(payload, 'newRoles', []).includes(SELF_ROLES.PANELIST));
-    this.set('selfIsAttendee', get(payload, 'newRoles', []).includes(SELF_ROLES.ATTENDEE));
-    this.updateCanManageWebcast(get(payload, 'newRoles', []).includes(SELF_ROLES.MODERATOR));
+      (oldRoles.includes(SELF_ROLES.PANELIST) && newRoles.includes(SELF_ROLES.ATTENDEE)) ||
+      (!oldRoles.includes(SELF_ROLES.ATTENDEE) && newRoles.includes(SELF_ROLES.ATTENDEE)); // for attendee just join meeting case
+    this.set('selfIsPanelist', newRoles.includes(SELF_ROLES.PANELIST));
+    this.set('selfIsAttendee', newRoles.includes(SELF_ROLES.ATTENDEE));
+    this.updateCanManageWebcast(newRoles.includes(SELF_ROLES.MODERATOR));
+    this.updateStatusByRole({isPromoted, isDemoted});
 
     return {isPromoted, isDemoted};
   },
+
+  /**
+   * should join practice session data channel or not
+   * @param {Object} {isPromoted: boolean, isDemoted: boolean}} Role transition states
+   * @returns {void}
+   */
+  updateStatusByRole({isPromoted, isDemoted}) {
+    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+
+    if (
+      (isDemoted && meeting?.shareStatus === SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE) ||
+      isPromoted
+    ) {
+      // attendees in webinar should subscribe streaming for whiteboard sharing
+      // while panelist still need subscribe native mode so trigger force update here
+      meeting?.locusInfo?.updateMediaShares(meeting?.locusInfo?.mediaShares, true);
+    }
+
+    if (this.practiceSessionEnabled) {
+      // may need change data channel in practice session
+      meeting?.updateLLMConnection();
+    }
+  },
+
+  /**
+   * should join practice session data channel or not
+   * @returns {boolean}
+   */
+  isJoinPracticeSessionDataChannel() {
+    return this.selfIsPanelist && this.practiceSessionEnabled;
+  },
+
+  /**
+   * start or stop practice session for webinar
+   * @param {boolean} enabled
+   * @returns {Promise}
+   */
+  setPracticeSessionState(enabled) {
+    return this.request({
+      method: HTTP_VERBS.PATCH,
+      uri: `${this.locusUrl}/controls`,
+      body: {
+        practiceSession: {
+          enabled,
+        },
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#setPracticeSessionState failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * update practice session status
+   * @param {object} payload
+   * @returns {void}
+   */
+  updatePracticeSessionStatus(payload) {
+    this.set('practiceSessionEnabled', payload.enabled);
+  },
+
+  /**
+   * start webcast mode for webinar
+   * @param {object} meeting
+   * @param {object} layout
+   * @returns {Promise}
+   */
+  async startWebcast(meeting, layout) {
+    if (!meeting) {
+      LoggerProxy.logger.error(
+        `Meeting:webinar#startWebcast failed --> meeting parameter : ${meeting}`
+      );
+      throw new Error('Meeting parameter does not meet expectations');
+    }
+
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      uri: `${this.webcastInstanceUrl}/streaming`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+        [HEADERS.CONTENT_TYPE]: HEADERS.CONTENT_TYPE_VALUE.APPLICATION_JSON,
+      },
+      body: {
+        action: 'start',
+        meetingInfo: {
+          locusId: meeting.locusId,
+          correlationId: meeting.correlationId,
+        },
+        layout,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#startWebcast failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * stop webcast mode for webinar
+   * @returns {Promise}
+   */
+  async stopWebcast() {
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      uri: `${this.webcastInstanceUrl}/streaming`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+        [HEADERS.CONTENT_TYPE]: HEADERS.CONTENT_TYPE_VALUE.APPLICATION_JSON,
+      },
+      body: {
+        action: 'stop',
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#stopWebcast failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * query webcast layout for webinar
+   * @returns {Promise}
+   */
+  async queryWebcastLayout() {
+    return this.request({
+      method: HTTP_VERBS.GET,
+      uri: `${this.webcastInstanceUrl}/layout`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#queryWebcastLayout failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * update webcast layout for webinar
+   * @param {object} layout
+   * @returns {Promise}
+   */
+  async updateWebcastLayout(layout) {
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      uri: `${this.webcastInstanceUrl}/layout`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+        [HEADERS.CONTENT_TYPE]: HEADERS.CONTENT_TYPE_VALUE.APPLICATION_JSON,
+      },
+      body: {
+        videoLayout: layout.videoLayout,
+        contentLayout: layout.contentLayout,
+        syncStageLayout: layout.syncStageLayout,
+        syncStageInMeeting: layout.syncStageInMeeting,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#updateWebcastLayout failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * view all webcast attendees
+   * @param {string} queryString
+   * @returns {Promise}
+   */
+  async viewAllWebcastAttendees() {
+    return this.request({
+      method: HTTP_VERBS.GET,
+      uri: `${this.webcastInstanceUrl}/attendees`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#viewAllWebcastAttendees failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * search webcast attendees by query string
+   * @param {string} queryString
+   * @returns {Promise}
+   */
+  async searchWebcastAttendees(queryString = '') {
+    return this.request({
+      method: HTTP_VERBS.GET,
+      uri: `${this.webcastInstanceUrl}/attendees?keyword=${encodeURIComponent(queryString)}`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#searchWebcastAttendees failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * expel webcast attendee by participantId
+   * @param {string} participantId
+   * @returns {Promise}
+   */
+  async expelWebcastAttendee(participantId) {
+    return this.request({
+      method: HTTP_VERBS.DELETE,
+      uri: `${this.webcastInstanceUrl}/attendees/${participantId}`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#expelWebcastAttendee failed', error);
+      throw error;
+    });
+  },
 });
 
 export default Webinar;

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

@@ -9,6 +9,7 @@ import LocusInfo from '@webex/plugin-meetings/src/locus-info';
 import SelfUtils from '@webex/plugin-meetings/src/locus-info/selfUtils';
 import InfoUtils from '@webex/plugin-meetings/src/locus-info/infoUtils';
 import EmbeddedAppsUtils from '@webex/plugin-meetings/src/locus-info/embeddedAppsUtils';
+import MediaSharesUtils from '@webex/plugin-meetings/src/locus-info//mediaSharesUtils';
 import LocusDeltaParser from '@webex/plugin-meetings/src/locus-info/parser';
 import Metrics from '@webex/plugin-meetings/src/metrics';
 
@@ -793,6 +794,75 @@ describe('plugin-meetings', () => {
     });
 
     describe('#updateSelf', () => {
+      it('should trigger SELF_MEETING_BRB_CHANGED when brb state changed', () => {
+        locusInfo.self = undefined;
+
+        const assertBrb = (enabled) => {
+          const selfWithBrbChanged = cloneDeep(self);
+          selfWithBrbChanged.controls.brb = enabled;
+
+          locusInfo.emitScoped = sinon.stub();
+          locusInfo.updateSelf(selfWithBrbChanged, []);
+
+          assert.calledWith(
+            locusInfo.emitScoped,
+            {file: 'locus-info', function: 'updateSelf'},
+            LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,
+            {brb: enabled}
+          );
+        };
+
+        assertBrb(true);
+        assertBrb(false);
+      });
+
+      it('should not trigger SELF_MEETING_BRB_CHANGED when brb state did not change', () => {
+        const assertBrbUnchanged = (value) => {
+          locusInfo.self = undefined;
+
+          const selfWithBrbChanged = cloneDeep(self);
+          selfWithBrbChanged.controls.brb = value;
+          locusInfo.self = selfWithBrbChanged;
+
+          locusInfo.emitScoped = sinon.stub();
+
+          const newSelf = cloneDeep(self);
+          newSelf.controls.brb = value;
+
+          locusInfo.updateSelf(newSelf, []);
+
+          assert.neverCalledWith(
+            locusInfo.emitScoped,
+            {file: 'locus-info', function: 'updateSelf'},
+            LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,
+            {brb: value}
+          );
+        };
+
+        assertBrbUnchanged(true);
+        assertBrbUnchanged(false);
+      });
+
+      it('should not trigger SELF_MEETING_BRB_CHANGED when brb state is undefined', () => {
+        const selfWithBrbChanged = cloneDeep(self);
+        selfWithBrbChanged.controls.brb = false;
+        locusInfo.self = selfWithBrbChanged;
+
+        locusInfo.emitScoped = sinon.stub();
+
+        const newSelf = cloneDeep(self);
+        newSelf.controls.brb = undefined;
+
+        locusInfo.updateSelf(newSelf, []);
+
+        assert.neverCalledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateSelf'},
+          LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,
+          {brb: undefined}
+        );
+      });
+
       it('should trigger CONTROLS_MEETING_LAYOUT_UPDATED when the meeting layout controls change', () => {
         const layoutType = 'EXAMPLE TYPE';
 
@@ -1388,6 +1458,30 @@ describe('plugin-meetings', () => {
           }
         );
       });
+
+      it('should not trigger any events if controls is undefined', () => {
+        locusInfo.self = self;
+        locusInfo.emitScoped = sinon.stub();
+        const newSelf = cloneDeep(self);
+        newSelf.controls = undefined;
+
+        locusInfo.updateSelf(newSelf, []);
+
+        const eventsSet = new Set([
+          LOCUSINFO.EVENTS.CONTROLS_MEETING_LAYOUT_UPDATED,
+          LOCUSINFO.EVENTS.SELF_MEETING_BREAKOUTS_CHANGED,
+          LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,
+          LOCUSINFO.EVENTS.SELF_MEETING_INTERPRETATION_CHANGED,
+          LOCUSINFO.EVENTS.LOCAL_UNMUTE_REQUIRED,
+          LOCUSINFO.EVENTS.SELF_REMOTE_MUTE_STATUS_UPDATED,
+        ]);
+
+        // check all events that contain logic on controls existence
+        locusInfo.emitScoped.getCalls().forEach((call) => {
+          const eventName = call.args[1];
+          assert.isFalse(eventsSet.has(eventName));
+        });
+      });
     });
 
     describe('#updateMeetingInfo', () => {
@@ -1637,6 +1731,134 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#updateMediaShares', () => {
+      let getMediaSharesSpy;
+
+      beforeEach(() => {
+        // Spy on MediaSharesUtils.getMediaShares
+        getMediaSharesSpy = sinon.stub(MediaSharesUtils, 'getMediaShares');
+
+        // Stub the emitScoped method to monitor its calls
+        sinon.stub(locusInfo, 'emitScoped');
+      });
+
+      afterEach(() => {
+        getMediaSharesSpy.restore();
+        locusInfo.emitScoped.restore();
+      });
+
+      it('should update media shares and emit LOCUS_INFO_UPDATE_MEDIA_SHARES when mediaShares change', () => {
+        const initialMediaShares = { audio: true, video: false };
+        const newMediaShares = { audio: false, video: true };
+
+        locusInfo.mediaShares = initialMediaShares;
+        locusInfo.parsedLocus = { mediaShares: null };
+
+        const parsedMediaShares = {
+          current: newMediaShares,
+          previous: initialMediaShares,
+        };
+
+        // Stub MediaSharesUtils.getMediaShares to return the expected parsedMediaShares
+        getMediaSharesSpy.returns(parsedMediaShares);
+
+        // Call the function
+        locusInfo.updateMediaShares(newMediaShares);
+
+        // Assert that MediaSharesUtils.getMediaShares was called with correct arguments
+        assert.calledWith(getMediaSharesSpy, initialMediaShares, newMediaShares);
+
+        // Assert that updateMeeting was called with the parsed current media shares
+        assert.deepEqual(locusInfo.parsedLocus.mediaShares, newMediaShares);
+        assert.deepEqual(locusInfo.mediaShares, newMediaShares);
+
+        // Assert that emitScoped was called with the correct event
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateMediaShares',
+          },
+          EVENTS.LOCUS_INFO_UPDATE_MEDIA_SHARES,
+          {
+            current: newMediaShares,
+            previous: initialMediaShares,
+            forceUpdate: false,
+          }
+        );
+      });
+
+      it('should force update media shares and emit LOCUS_INFO_UPDATE_MEDIA_SHARES even if shares are the same', () => {
+        const initialMediaShares = { audio: true, video: false };
+        locusInfo.mediaShares = initialMediaShares;
+        locusInfo.parsedLocus = { mediaShares: null };
+
+        const parsedMediaShares = {
+          current: initialMediaShares,
+          previous: initialMediaShares,
+        };
+
+        getMediaSharesSpy.returns(parsedMediaShares);
+
+        // Call the function with forceUpdate = true
+        locusInfo.updateMediaShares(initialMediaShares, true);
+
+        // Assert that MediaSharesUtils.getMediaShares was called
+        assert.calledWith(getMediaSharesSpy, initialMediaShares, initialMediaShares);
+
+        // Assert that emitScoped was called with the correct event
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateMediaShares',
+          },
+          EVENTS.LOCUS_INFO_UPDATE_MEDIA_SHARES,
+          {
+            current: initialMediaShares,
+            previous: initialMediaShares,
+            forceUpdate: true,
+          }
+        );
+      });
+
+      it('should not emit LOCUS_INFO_UPDATE_MEDIA_SHARES if mediaShares do not change and forceUpdate is false', () => {
+        const initialMediaShares = { audio: true, video: false };
+        locusInfo.mediaShares = initialMediaShares;
+
+        // Call the function with the same mediaShares and forceUpdate = false
+        locusInfo.updateMediaShares(initialMediaShares);
+
+        // Assert that MediaSharesUtils.getMediaShares was not called
+        assert.notCalled(getMediaSharesSpy);
+
+        // Assert that emitScoped was not called
+        assert.notCalled(locusInfo.emitScoped);
+      });
+
+      it('should update internal state correctly when mediaShares are updated', () => {
+        const initialMediaShares = { audio: true, video: false };
+        const newMediaShares = { audio: false, video: true };
+
+        locusInfo.mediaShares = initialMediaShares;
+        locusInfo.parsedLocus = { mediaShares: null };
+
+        const parsedMediaShares = {
+          current: newMediaShares,
+          previous: initialMediaShares,
+        };
+
+        getMediaSharesSpy.returns(parsedMediaShares);
+
+        // Call the function
+        locusInfo.updateMediaShares(newMediaShares);
+
+        // Assert that the internal state was updated correctly
+        assert.deepEqual(locusInfo.parsedLocus.mediaShares, newMediaShares);
+        assert.deepEqual(locusInfo.mediaShares, newMediaShares);
+      });
+    });
+
     describe('#updateEmbeddedApps()', () => {
       const newEmbeddedApps = [
         {

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

@@ -304,6 +304,13 @@ export const selfWithInactivity = {
     localRecord: {
       recording: false,
     },
+    brb: {
+      enabled: true,
+      meta: {
+        lastModified: '2024-10-24T14:05:58.526Z',
+        modifiedBy: '70978427-8238-4ffc-9227-8baf4b80b831',
+      },
+    },
     layouts: [
       {
         type: 'activePresence',