@webex/plugin-meetings 3.8.1-web-workers-keepalive.1 → 3.9.0-webinar5k.1

package/src/locus-info/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable class-methods-use-this */
 import {isEqual, assignWith, cloneDeep, isEmpty, forEach} from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
@@ -30,6 +31,87 @@ import MediaSharesUtils from './mediaSharesUtils';
 import LocusDeltaParser from './parser';
 import Metrics from '../metrics';
 import BEHAVIORAL_METRICS from '../metrics/constants';
+import HashTreeParser, {
+  DataSet,
+  HashTreeMessage,
+  HashTreeObject,
+  HtMeta,
+  LocusInfoUpdateType,
+  ObjectType,
+} from '../hashTree/hashTreeParser';
+
+export type LocusLLMEvent = {
+  data: {
+    eventType: 'locus.state_message';
+    stateElementsMessage: HashTreeMessage;
+  };
+};
+
+export type LocusDTO = {
+  controls?: any;
+  fullState?: {
+    active: boolean;
+    count: number;
+    lastActive: string;
+    locked: boolean;
+    sessionId: string;
+    seessionIds: string[];
+    startTime: number;
+    state: string;
+    type: string;
+  };
+  host?: {
+    id: string;
+    incomingCallProtocols: any[];
+    isExternal: boolean;
+    name: string;
+    orgId: string;
+  };
+  htMeta?: HtMeta;
+  info?: any;
+  jsSdkMeta?: {
+    removedParticipantIds: string[]; // list of ids of participants that are removed in the last update
+  };
+  links?: any;
+  mediaShares?: any[];
+  meetings?: any[];
+  participants: any[];
+  replaces?: any[];
+  self?: any;
+  sequence?: {
+    dirtyParticipants: number;
+    entries: number[];
+    rangeEnd: number;
+    rangeStart: number;
+    sequenceHash: number;
+    sessionToken: string;
+    since: string;
+    totalParticipants: number;
+  };
+  syncUrl?: string;
+  url?: string;
+};
+
+export type LocusApiResponseBody = {
+  dataSets?: DataSet[];
+  locus: LocusDTO; // this LocusDTO here might not be the full one (for example it won't have all the participants, but it should have self)
+};
+
+const LocusDtoTopLevelKeys = [
+  'controls',
+  'fullState',
+  'host',
+  'info',
+  'links',
+  'mediaShares',
+  'meetings',
+  'participants',
+  'replaces',
+  'self',
+  'sequence',
+  'syncUrl',
+  'url',
+];
 
 /**
  * @description LocusInfo extends ChildEmitter to convert locusInfo info a private emitter to parent object
@@ -70,6 +152,9 @@ export default class LocusInfo extends EventsScope {
   resources: any;
   mainSessionLocusCache: any;
   self: any;
+  hashTreeParser?: HashTreeParser;
+  hashTreeObjectId2ParticipantId: Map<number, string>; // mapping of hash tree object ids to participant ids
+
   /**
    * Constructor
    * @param {function} updateMeeting callback to update the meeting object from an object
@@ -88,6 +173,7 @@ export default class LocusInfo extends EventsScope {
     this.meetingId = meetingId;
     this.updateMeeting = updateMeeting;
     this.locusParser = new LocusDeltaParser();
+    this.hashTreeObjectId2ParticipantId = new Map();
   }
 
   /**
@@ -99,6 +185,7 @@ export default class LocusInfo extends EventsScope {
   private doLocusSync(meeting: any) {
     let isDelta;
     let url;
+    let meetingDestroyed = false;
 
     if (this.locusParser.workingCopy.syncUrl) {
       url = this.locusParser.workingCopy.syncUrl;
@@ -134,32 +221,56 @@ export default class LocusInfo extends EventsScope {
 
           isDelta = false;
 
-          return meeting.meetingRequest.getLocusDTO({url: meeting.locusUrl}).catch((err) => {
-            LoggerProxy.logger.info(
-              'Locus-info:index#doLocusSync --> fallback full sync failed, destroying the meeting'
-            );
-            this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.LOCUS_DTO_SYNC_FAILED);
-            throw err;
-          });
+          // Locus sometimes returns 403, for example if meeting has ended, no point trying the fallback to full sync in that case
+          if (e.statusCode !== 403) {
+            return meeting.meetingRequest.getLocusDTO({url: meeting.locusUrl}).catch((err) => {
+              LoggerProxy.logger.info(
+                'Locus-info:index#doLocusSync --> fallback full sync failed, destroying the meeting'
+              );
+              this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.LOCUS_DTO_SYNC_FAILED);
+              meetingDestroyed = true;
+              throw err;
+            });
+          }
+          LoggerProxy.logger.info(
+            'Locus-info:index#doLocusSync --> got 403 from Locus, skipping fallback to full sync, destroying the meeting'
+          );
+        } else {
+          LoggerProxy.logger.info(
+            'Locus-info:index#doLocusSync --> fallback full sync failed, destroying the meeting'
+          );
         }
-        LoggerProxy.logger.info(
-          'Locus-info:index#doLocusSync --> fallback full sync failed, destroying the meeting'
-        );
         this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.LOCUS_DTO_SYNC_FAILED);
+        meetingDestroyed = true;
         throw e;
       })
       .then((res) => {
-        if (isDelta) {
-          if (!isEmpty(res.body)) {
-            meeting.locusInfo.handleLocusDelta(res.body, meeting);
-          } else {
+        if (isEmpty(res.body)) {
+          if (isDelta) {
             LoggerProxy.logger.info(
               'Locus-info:index#doLocusSync --> received empty body from syncUrl, so we already have latest Locus DTO'
             );
+          } else {
+            LoggerProxy.logger.info(
+              'Locus-info:index#doLocusSync --> received empty body from full DTO sync request'
+            );
           }
-        } else {
-          meeting.locusInfo.onFullLocus(res.body);
+
+          return;
         }
+
+        if (isDelta) {
+          if (res.body.baseSequence) {
+            meeting.locusInfo.handleLocusDelta(res.body, meeting); // todo: check if this is safe, is isDelta=true always only for non-hash tree locus
+
+            return;
+          }
+          // in some cases Locus might return us full DTO even when we asked for a delta
+          LoggerProxy.logger.info(
+            'Locus-info:index#doLocusSync --> got full DTO when we asked for delta'
+          );
+        }
+        meeting.locusInfo.onFullLocus(res.body);
       })
       .catch((e) => {
         LoggerProxy.logger.info(
@@ -176,9 +287,11 @@ export default class LocusInfo extends EventsScope {
         });
       })
       .finally(() => {
-        // Notify parser to resume processing delta events.
-        // Any deltas in the queue that have now been superseded by this sync will simply be ignored
-        this.locusParser.resume();
+        if (!meetingDestroyed) {
+          // Notify parser to resume processing delta events.
+          // Any deltas in the queue that have now been superseded by this sync will simply be ignored
+          this.locusParser.resume();
+        }
       });
   }
 
@@ -271,7 +384,7 @@ export default class LocusInfo extends EventsScope {
     this.updateLocusCache(locus);
     // above section only updates the locusInfo object
     // The below section makes sure it updates the locusInfo as well as updates the meeting object
-    this.updateParticipants(locus.participants);
+    this.updateParticipants(locus.participants, []);
     // For 1:1 space meeting the conversation Url does not exist in locus.conversation
     this.updateConversationUrl(locus.conversationUrl, locus.info);
     this.updateControls(locus.controls, locus.self);
@@ -289,17 +402,190 @@ export default class LocusInfo extends EventsScope {
 
   /**
    * @param {Object} locus
+   * @param {DataSet[]} [dataSets=[]] - Array of data sets
    * @returns {undefined}
    * @memberof LocusInfo
    */
-  initialSetup(locus: object) {
+  initialSetup(locus: object, dataSets: DataSet[] = []) {
     this.updateLocusCache(locus);
-    this.onFullLocus(locus);
+    this.onFullLocus(locus, undefined, dataSets);
 
     // Change it to true after it receives it first locus object
     this.emitChange = true;
   }
 
+  /**
+   *
+   * @param {HashTreeObject} object data set object
+   * @param {any} locus
+   * @returns {void}
+   */
+  updateHashTreeObjectInLocus(object: HashTreeObject, locus: LocusDTO): LocusDTO {
+    const type = object.htMeta.elementId.type.toLowerCase();
+
+    switch (type) {
+      case ObjectType.locus: {
+        if (!object.data) {
+          LoggerProxy.logger.warn(
+            `Locus-info:index#updateHashTreeObjectInLocus --> received LOCUS object without data, this is not supported!`
+          );
+
+          return locus;
+        }
+        // replace the main locus
+
+        // The Locus object from MAIN dataset has empty participants, so removing them to avoid it overriding the ones in our current locus object
+        // Also, it doesn't have "self". That's OK as it won't override existing locus.self and also existing SDK code can handle that missing self in Locus updates
+        const locusObjectFromData = object.data;
+        delete locusObjectFromData.participants;
+
+        locus = {...locus, ...locusObjectFromData};
+        locus.htMeta = object.htMeta;
+        break;
+      }
+      case ObjectType.participant:
+        LoggerProxy.logger.info(
+          `Locus-info:index#updateHashTreeObjectInLocus --> participant id=${
+            object.htMeta.elementId.id
+          } ${object.data ? 'updated' : 'removed'}`
+        );
+        console.log(
+          'marcin: hashTreeObjectId2ParticipantId=',
+          cloneDeep(this.hashTreeObjectId2ParticipantId)
+        );
+        if (object.data) {
+          if (!locus.participants) {
+            locus.participants = [];
+          }
+          const participantObject = object.data;
+          participantObject.htMeta = object.htMeta;
+          locus.participants.push(participantObject);
+          this.hashTreeObjectId2ParticipantId.set(object.htMeta.elementId.id, participantObject.id);
+        } else {
+          const participantId = this.hashTreeObjectId2ParticipantId.get(object.htMeta.elementId.id);
+
+          if (!locus.jsSdkMeta) {
+            locus.jsSdkMeta = {removedParticipantIds: []};
+          }
+          locus.jsSdkMeta.removedParticipantIds.push(participantId);
+          this.hashTreeObjectId2ParticipantId.delete(object.htMeta.elementId.id);
+        }
+        break;
+      case ObjectType.self:
+        if (!object.data) {
+          LoggerProxy.logger.warn(
+            `Locus-info:index#updateHashTreeObjectInLocus --> received SELF object without data, this is not supported!`
+          );
+
+          return locus;
+        }
+        locus.self = object.data;
+        break;
+    }
+
+    return locus;
+  }
+
+  /**
+   * Handles HTTP response from Locus API call when hash tree update.
+   * @param {Meeting} meeting meeting object
+   * @param {LocusApiResponseBody} responseBody body of the http reponse from Locus API call
+   * @returns {void}
+   */
+  handleLocusAPIResponse(meeting, responseBody: LocusApiResponseBody): void {
+    console.log('marcin: locus response from API call:', responseBody);
+    if (responseBody.dataSets) {
+      if (!this.hashTreeParser) {
+        LoggerProxy.logger.warn(
+          `Locus-info:index#handleLocusAPIResponse --> received response with hash tree info from Locus API, but we don't have the hashTreeParser created`
+        );
+
+        return;
+      }
+      // Locus is using the new hash tree mechanism
+      // so update our data in the hash tree parser
+      this.hashTreeParser.handleLocusUpdate(responseBody);
+
+      // but the Locus object we receive in this case looks same like classic delta, so we can use existing delta method to process it
+      this.onDeltaLocus(responseBody.locus);
+    } else {
+      // classic Locus delta
+      this.handleLocusDelta(responseBody.locus, meeting);
+    }
+  }
+
+  /**
+   * Handles a hash tree message received from Locus.
+   *
+   * @param {Meeting} meeting - The meeting object
+   * @param {HashTreeMessage} message incoming hash tree message
+   * @returns {void}
+   */
+  private handleHashTreeMessage(meeting: any, message: HashTreeMessage) {
+    if (!this.hashTreeParser) {
+      LoggerProxy.logger.warn(
+        `Locus-info:index#handleHashTreeMessage --> received hash tree message, but we don't have the hashTreeParser`
+      );
+
+      return;
+    }
+    if (message.locusStateElements === undefined) {
+      // todo: need to see in practice how exactly the heartbeat messages look like
+      this.hashTreeParser.handleRootHashHeartBeatMessage(message);
+    } else {
+      this.hashTreeParser.handleMessage(message);
+    }
+  }
+
+  /**
+   * Updates our locus info based on the data parsed by the hash tree parser.
+   *
+   * @param {LocusInfoUpdateType} updateType - The type of update received.
+   * @param {Object} [data] - Additional data for the update, if applicable.
+   * @returns {void}
+   */
+  private updateFromHashTree(
+    updateType: LocusInfoUpdateType,
+    data?: {updatedObjects: HashTreeObject[]}
+  ) {
+    switch (updateType) {
+      case LocusInfoUpdateType.OBJECTS_UPDATED: {
+        // initialize the main locus with what we currently have
+        // but with empty participants array
+        let locus: LocusDTO = {
+          participants: [],
+          jsSdkMeta: {removedParticipantIds: []},
+        };
+
+        LocusDtoTopLevelKeys.forEach((key) => {
+          if (key === 'participants') {
+            locus[key] = [];
+          } else {
+            locus[key] = cloneDeep(this[key]);
+          }
+        });
+
+        // apply the updates from the hash tree onto the locus
+        data.updatedObjects.forEach((object) => {
+          locus = this.updateHashTreeObjectInLocus(object, locus);
+        });
+
+        // update our locus info with the new locus
+        this.onDeltaLocus(locus);
+
+        break;
+      }
+
+      case LocusInfoUpdateType.MEETING_ENDED: {
+        LoggerProxy.logger.info(
+          `Locus-info:index#updateFromHashTree --> received signal that meeting ended, destroying meeting ${this.meetingId}`
+        );
+        const meeting = this.webex.meetings.meetingCollection.get(this.meetingId);
+        this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.LOCUS_DTO_SYNC_FAILED);
+      }
+    }
+  }
+
   /**
    * @param {Meeting} meeting
    * @param {Object} data
@@ -307,36 +593,43 @@ export default class LocusInfo extends EventsScope {
    * @memberof LocusInfo
    */
   parse(meeting: any, data: any) {
-    // eslint-disable-next-line @typescript-eslint/no-shadow
-    const {eventType} = data;
-    const locus = this.getTheLocusToUpdate(data.locus);
-    LoggerProxy.logger.info(`Locus-info:index#parse --> received locus data: ${eventType}`);
-
-    switch (eventType) {
-      case LOCUSEVENT.PARTICIPANT_JOIN:
-      case LOCUSEVENT.PARTICIPANT_LEFT:
-      case LOCUSEVENT.CONTROLS_UPDATED:
-      case LOCUSEVENT.PARTICIPANT_AUDIO_MUTED:
-      case LOCUSEVENT.PARTICIPANT_AUDIO_UNMUTED:
-      case LOCUSEVENT.PARTICIPANT_VIDEO_MUTED:
-      case LOCUSEVENT.PARTICIPANT_VIDEO_UNMUTED:
-      case LOCUSEVENT.SELF_CHANGED:
-      case LOCUSEVENT.PARTICIPANT_UPDATED:
-      case LOCUSEVENT.PARTICIPANT_CONTROLS_UPDATED:
-      case LOCUSEVENT.PARTICIPANT_ROLES_UPDATED:
-      case LOCUSEVENT.PARTICIPANT_DECLINED:
-      case LOCUSEVENT.FLOOR_GRANTED:
-      case LOCUSEVENT.FLOOR_RELEASED:
-        this.onFullLocus(locus, eventType);
-        break;
-      case LOCUSEVENT.DIFFERENCE:
-        this.handleLocusDelta(locus, meeting);
-        break;
-
-      default:
-        // Why will there be a event with no eventType ????
-        // we may not need this, we can get full locus
-        this.handleLocusDelta(locus, meeting);
+    if (data.eventType === 'locus.state_message') {
+      // this is the new hashmap Locus message format (only applicable to webinars for now)
+      this.handleHashTreeMessage(meeting, data.stateElementsMessage as HashTreeMessage);
+    } else {
+      // eslint-disable-next-line @typescript-eslint/no-shadow
+      const {eventType} = data;
+      const locus = this.getTheLocusToUpdate(data.locus);
+      LoggerProxy.logger.info(`Locus-info:index#parse --> received locus data: ${eventType}`);
+
+      locus.jsSdkMeta = {removedParticipantIds: []};
+
+      switch (eventType) {
+        case LOCUSEVENT.PARTICIPANT_JOIN:
+        case LOCUSEVENT.PARTICIPANT_LEFT:
+        case LOCUSEVENT.CONTROLS_UPDATED:
+        case LOCUSEVENT.PARTICIPANT_AUDIO_MUTED:
+        case LOCUSEVENT.PARTICIPANT_AUDIO_UNMUTED:
+        case LOCUSEVENT.PARTICIPANT_VIDEO_MUTED:
+        case LOCUSEVENT.PARTICIPANT_VIDEO_UNMUTED:
+        case LOCUSEVENT.SELF_CHANGED:
+        case LOCUSEVENT.PARTICIPANT_UPDATED:
+        case LOCUSEVENT.PARTICIPANT_CONTROLS_UPDATED:
+        case LOCUSEVENT.PARTICIPANT_ROLES_UPDATED:
+        case LOCUSEVENT.PARTICIPANT_DECLINED:
+        case LOCUSEVENT.FLOOR_GRANTED:
+        case LOCUSEVENT.FLOOR_RELEASED:
+          this.onFullLocus(locus, eventType);
+          break;
+        case LOCUSEVENT.DIFFERENCE:
+          this.handleLocusDelta(locus, meeting);
+          break;
+
+        default:
+          // Why will there be a event with no eventType ????
+          // we may not need this, we can get full locus
+          this.handleLocusDelta(locus, meeting);
+      }
     }
   }
 
@@ -355,17 +648,46 @@ export default class LocusInfo extends EventsScope {
    * updates the locus with full locus object
    * @param {object} locus locus object
    * @param {string} eventType particulat locus event
+   * @param {DataSet[]} dataSets
    * @returns {object} null
    * @memberof LocusInfo
    */
-  onFullLocus(locus: any, eventType?: string) {
+  onFullLocus(locus: any, eventType?: string, dataSets?: Array<DataSet>) {
     if (!locus) {
       LoggerProxy.logger.error(
         'Locus-info:index#onFullLocus --> object passed as argument was invalid, continuing.'
       );
     }
 
-    if (!this.locusParser.isNewFullLocus(locus)) {
+    if (dataSets) {
+      // this is the new hashmap Locus DTO format (only applicable to webinars for now)
+      if (!this.hashTreeParser) {
+        LoggerProxy.logger.info(`Locus-info:index#onFullLocus --> creating hash tree parser`);
+        LoggerProxy.logger.info(
+          'Locus-info:index#onFullLocus --> dataSets:',
+          dataSets,
+          ' and locus:',
+          locus
+        );
+        this.hashTreeParser = new HashTreeParser({
+          initialLocus: {locus, dataSets},
+          webexRequest: this.webex.request.bind(this.webex),
+          locusInfoUpdateCallback: this.updateFromHashTree.bind(this),
+          debugId: `HT-${this.meetingId.substring(0, 4)}`,
+        });
+      } else {
+        // in this case the Locus we're getting is not necessarily the full one
+        // so treat it like if we just got it in a message
+        console.log('marcin: !!!!!!!! full DTO - this is not fully implemented/tested yet');
+
+        LoggerProxy.logger.warn(
+          'Locus-info:index#onFullLocus --> full DTO - this is not fully implemented/tested yet!!!!!!!!'
+        );
+        this.handleLocusAPIResponse(undefined, {dataSets, locus});
+
+        return;
+      }
+    } else if (!this.locusParser.isNewFullLocus(locus)) {
       LoggerProxy.logger.info(
         `Locus-info:index#onFullLocus --> ignoring old full locus DTO, eventType=${eventType}`
       );
@@ -376,9 +698,16 @@ export default class LocusInfo extends EventsScope {
     this.updateParticipantDeltas(locus.participants);
     this.scheduledMeeting = locus.meeting || null;
     this.participants = locus.participants;
+    this.participants?.forEach((participant) => {
+      this.hashTreeObjectId2ParticipantId.set(participant.htMeta.elementId.id, participant.id);
+    });
     const isReplaceMembers = ControlsUtils.isNeedReplaceMembers(this.controls, locus.controls);
     this.updateLocusInfo(locus);
-    this.updateParticipants(locus.participants, isReplaceMembers);
+    this.updateParticipants(
+      locus.participants,
+      locus.jsSdkMeta?.removedParticipantIds,
+      isReplaceMembers
+    );
     this.isMeetingActive();
     this.handleOneOnOneEvent(eventType);
     this.updateEmbeddedApps(locus.embeddedApps);
@@ -440,7 +769,11 @@ export default class LocusInfo extends EventsScope {
     const isReplaceMembers = ControlsUtils.isNeedReplaceMembers(this.controls, locus.controls);
     this.mergeParticipants(this.participants, locus.participants);
     this.updateLocusInfo(locus);
-    this.updateParticipants(locus.participants, isReplaceMembers);
+    this.updateParticipants(
+      locus.participants,
+      locus.jsSdkMeta?.removedParticipantIds,
+      isReplaceMembers
+    );
     this.isMeetingActive();
   }
 
@@ -462,12 +795,12 @@ export default class LocusInfo extends EventsScope {
     this.updateCreated(locus.created);
     this.updateFullState(locus.fullState);
     this.updateHostInfo(locus.host);
+    this.updateLocusUrl(locus.url);
     this.updateMeetingInfo(locus.info, locus.self);
     this.updateMediaShares(locus.mediaShares);
     this.updateParticipantsUrl(locus.participantsUrl);
     this.updateReplace(locus.replace);
     this.updateSelf(locus.self);
-    this.updateLocusUrl(locus.url);
     this.updateAclUrl(locus.aclUrl);
     this.updateBasequence(locus.baseSequence);
     this.updateSequence(locus.sequence);
@@ -780,11 +1113,12 @@ export default class LocusInfo extends EventsScope {
   /**
    * update meeting's members
    * @param {Object} participants new participants object
+   * @param {Array} removedParticipantIds list of removed participants
    * @param {Boolean} isReplace is replace the whole members
    * @returns {Array} updatedParticipants
    * @memberof LocusInfo
    */
-  updateParticipants(participants: object, isReplace?: boolean) {
+  updateParticipants(participants: object, removedParticipantIds: string[], isReplace?: boolean) {
     this.emitScoped(
       {
         file: 'locus-info',
@@ -793,6 +1127,7 @@ export default class LocusInfo extends EventsScope {
       EVENTS.LOCUS_INFO_UPDATE_PARTICIPANTS,
       {
         participants,
+        removedParticipantIds,
         recordingId: this.parsedLocus.controls && this.parsedLocus.controls.record?.modifiedBy,
         selfIdentity: this.parsedLocus.self && this.parsedLocus.self.selfIdentity,
         selfId: this.parsedLocus.self && this.parsedLocus.self.selfId,

package/src/meeting/brbState.ts

@@ -58,7 +58,13 @@ export class BrbState {
   public enable(enabled: boolean, sendSlotManager: SendSlotManager) {
     this.state.client.enabled = enabled;
 
-    return this.applyClientStateToServer(sendSlotManager);
+    // Don't set the source state override if enabling brb fails
+    return this.applyClientStateToServer(sendSlotManager).then(() => {
+      sendSlotManager.setSourceStateOverride(
+        MediaType.VideoMain,
+        this.state.client.enabled ? 'away' : null
+      );
+    });
   }
 
   /**
@@ -92,7 +98,7 @@ export class BrbState {
 
     this.state.syncToServerInProgress = true;
 
-    return this.sendLocalBrbStateToServer(sendSlotManager)
+    return this.sendLocalBrbStateToServer()
       .then(() => {
         this.state.syncToServerInProgress = false;
 
@@ -120,10 +126,9 @@ export class BrbState {
   /**
    * Send the local brb state to the server
    *
-   * @param {SendSlotManager} sendSlotManager
    * @returns {Promise}
    */
-  private async sendLocalBrbStateToServer(sendSlotManager: SendSlotManager) {
+  private async sendLocalBrbStateToServer() {
     const {enabled} = this.state.client;
 
     if (!this.meeting.isMultistream) {
@@ -153,9 +158,6 @@ export class BrbState {
         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);