@webex/plugin-meetings 3.7.0 → 3.8.0

package/src/common/errors/multistream-not-supported-error.ts

@@ -0,0 +1,30 @@
+import {ERROR_DICTIONARY} from '../../constants';
+
+/**
+ * Error thrown when we try to do multistream, but fail. This error
+ * is not exported outside of plugin-meetings, because it's handled
+ * internally.
+ */
+export default class MultistreamNotSupportedError extends Error {
+  code: any;
+  error: any;
+  sdkMessage: any;
+
+  /**
+   *
+   * @constructor
+   * @param {String} [message]
+   * @param {Object} [error]
+   */
+  constructor(
+    message: string = ERROR_DICTIONARY.MULTISTREAM_NOT_SUPPORTED.MESSAGE,
+    error: any = null
+  ) {
+    super(message);
+    this.name = ERROR_DICTIONARY.MULTISTREAM_NOT_SUPPORTED.NAME;
+    this.sdkMessage = ERROR_DICTIONARY.MULTISTREAM_NOT_SUPPORTED.MESSAGE;
+    this.error = error;
+    this.stack = error ? error.stack : new Error().stack;
+    this.code = ERROR_DICTIONARY.MULTISTREAM_NOT_SUPPORTED.CODE;
+  }
+}

package/src/config.ts

@@ -96,5 +96,6 @@ export default {
     iceCandidatesGatheringTimeout: undefined,
     backendIpv6NativeSupport: false,
     reachabilityGetClusterTimeout: 5000,
+    logUploadIntervalMultiplicationFactor: 0, // if set to 0 or undefined, logs won't be uploaded periodically, if you want periodic logs, recommended value is 1
   },
 };

package/src/constants.ts

@@ -36,6 +36,8 @@ export const HOST = 'host';
 
 export const JOIN = 'join';
 
+export const JOIN_LINK_MTID = 'MTID';
+
 export const LEAVE = 'leave';
 export const LIVE = 'live';
 export const LOCAL = 'local';
@@ -104,6 +106,7 @@ export const _ON_HOLD_LOBBY_ = 'ON_HOLD_LOBBY';
 export const _MEETING_LINK_ = 'MEETING_LINK';
 export const _MEETING_UUID_ = 'MEETING_UUID';
 export const _MEETING_ = 'MEETING';
+export const _SPACE_SHARE_ = 'SPACE_SHARE';
 export const _MEETING_CENTER_ = 'MEETING_CENTER';
 export const _MEETING_ID_ = 'MEETING_ID';
 
@@ -198,6 +201,9 @@ export const RETRY_TIMEOUT = 3000;
 
 export const ICE_AND_DTLS_CONNECTION_TIMEOUT = 20000;
 export const ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT = 35000;
+export const WEBINAR_ERROR_WEBCAST = [403026];
+export const WEBINAR_ERROR_REGISTRATION_ID = [403037, 403137];
+export const JOIN_BEFORE_HOST = 403003;
 
 // ******************** REGEX **********************
 // Please alphabetize
@@ -303,6 +309,7 @@ export const EVENT_TRIGGERS = {
   MEETING_SELF_CANNOT_VIEW_PARTICIPANT_LIST: 'meeting:self:cannotViewParticipantList',
   MEETING_SELF_IS_SHARING_BLOCKED: 'meeting:self:isSharingBlocked',
   MEETING_SELF_ROLES_CHANGED: 'meeting:self:rolesChanged',
+  MEETING_SELF_BRB_UPDATE: 'meeting:self:brbUpdate',
   MEETING_CONTROLS_LAYOUT_UPDATE: 'meeting:layout:update',
   MEETING_ENTRY_EXIT_TONE_UPDATE: 'meeting:entryExitTone:update',
   MEETING_BREAKOUTS_UPDATE: 'meeting:breakouts:update',
@@ -325,6 +332,7 @@ export const EVENT_TRIGGERS = {
   MEETING_RECONNECTION_FAILURE: 'meeting:reconnectionFailure',
   MEETING_UNLOCKED: 'meeting:unlocked',
   MEETING_LOCKED: 'meeting:locked',
+  MEETING_RESOURCE_LINKS_UPDATE: 'meeting:resourceLinks:update',
   MEETING_INFO_AVAILABLE: 'meeting:meetingInfoAvailable',
   MEETING_INFO_UPDATED: 'meeting:meetingInfoUpdated',
   MEETING_LOG_UPLOAD_SUCCESS: 'meeting:logUpload:success',
@@ -383,6 +391,13 @@ export const EVENT_TYPES = {
   ERROR: 'error',
 };
 
+export const HEADERS = {
+  CONTENT_TYPE: 'Content-Type',
+  CONTENT_TYPE_VALUE: {
+    APPLICATION_JSON: 'application/json',
+  },
+};
+
 // Handles the reason when meeting gets destroyed
 // host removed you from the meeting
 // You are the host and you left the meeting
@@ -529,11 +544,21 @@ export const ERROR_DICTIONARY = {
       'Reconnection was not started, because there is one already in progress or reconnections are disabled in config.',
     CODE: 15,
   },
-  WebinarRegistrationError: {
-    NAME: 'WebinarRegistrationError',
-    MESSAGE: 'An error occurred while the webinar required registration.',
+  JoinWebinarError: {
+    NAME: 'JoinWebinarError',
+    MESSAGE: 'An error occurred while the join webinar.',
     CODE: 16,
   },
+  MULTISTREAM_NOT_SUPPORTED: {
+    NAME: 'MultistreamNotSupported',
+    MESSAGE: 'Client asked for multistream backend (Homer), but got something else instead',
+    CODE: 17,
+  },
+  JoinForbiddenError: {
+    NAME: 'JoinForbiddenError',
+    MESSAGE: 'Meeting join forbidden.',
+    CODE: 18,
+  },
 };
 
 export const FLOOR_ACTION = {
@@ -709,6 +734,7 @@ export const LOCUSINFO = {
     SELF_IS_SHARING_BLOCKED_CHANGE: 'SELF_IS_SHARING_BLOCKED_CHANGE',
     SELF_MEETING_BREAKOUTS_CHANGED: 'SELF_MEETING_BREAKOUTS_CHANGED',
     SELF_MEETING_INTERPRETATION_CHANGED: 'SELF_MEETING_INTERPRETATION_CHANGED',
+    SELF_MEETING_BRB_CHANGED: 'SELF_MEETING_BRB_CHANGED',
     MEDIA_INACTIVITY: 'MEDIA_INACTIVITY',
     LINKS_SERVICES: 'LINKS_SERVICES',
     LINKS_RESOURCES: 'LINKS_RESOURCES',
@@ -904,6 +930,10 @@ export const DISPLAY_HINTS = {
   RECORDING_CONTROL_PAUSE: 'RECORDING_CONTROL_PAUSE',
   RECORDING_CONTROL_STOP: 'RECORDING_CONTROL_STOP',
   RECORDING_CONTROL_RESUME: 'RECORDING_CONTROL_RESUME',
+  PREMISE_RECORDING_CONTROL_START: 'PREMISE_RECORDING_CONTROL_START',
+  PREMISE_RECORDING_CONTROL_PAUSE: 'PREMISE_RECORDING_CONTROL_PAUSE',
+  PREMISE_RECORDING_CONTROL_STOP: 'PREMISE_RECORDING_CONTROL_STOP',
+  PREMISE_RECORDING_CONTROL_RESUME: 'PREMISE_RECORDING_CONTROL_RESUME',
   LOCK_CONTROL_UNLOCK: 'LOCK_CONTROL_UNLOCK',
   LOCK_CONTROL_LOCK: 'LOCK_CONTROL_LOCK',
   LOCK_STATUS_LOCKED: 'LOCK_STATUS_LOCKED',
@@ -950,6 +980,7 @@ export const DISPLAY_HINTS = {
   DISABLE_ASK_FOR_HELP: 'DISABLE_ASK_FOR_HELP',
   DISABLE_BREAKOUT_PREASSIGNMENTS: 'DISABLE_BREAKOUT_PREASSIGNMENTS',
   DISABLE_LOBBY_TO_BREAKOUT: 'DISABLE_LOBBY_TO_BREAKOUT',
+  DISABLE_BREAKOUT_START: 'DISABLE_BREAKOUT_START',
 
   // participants list
   DISABLE_VIEW_THE_PARTICIPANT_LIST: 'DISABLE_VIEW_THE_PARTICIPANT_LIST',
@@ -988,6 +1019,12 @@ export const DISPLAY_HINTS = {
   STAGE_VIEW_INACTIVE: 'STAGE_VIEW_INACTIVE',
   ENABLE_STAGE_VIEW: 'ENABLE_STAGE_VIEW',
   DISABLE_STAGE_VIEW: 'DISABLE_STAGE_VIEW',
+
+  // Practice Session
+  PRACTICE_SESSION_ON: 'PRACTICE_SESSION_ON',
+  PRACTICE_SESSION_OFF: 'PRACTICE_SESSION_OFF',
+  SHOW_PRACTICE_SESSION_START: 'SHOW_PRACTICE_SESSION_START',
+  SHOW_PRACTICE_SESSION_STOP: 'SHOW_PRACTICE_SESSION_STOP',
 };
 
 export const INTERSTITIAL_DISPLAY_HINTS = [DISPLAY_HINTS.VOIP_IS_ENABLED];
@@ -1294,12 +1331,24 @@ export const PASSWORD_STATUS = {
   VERIFIED: 'VERIFIED', // client has already provided the password and it has been verified, client can proceed to call join()
 };
 
+export const REGISTRATION_ID_STATUS = {
+  NOT_REQUIRED: 'NOT_REQUIRED', // registrationId is not required to join the meeting
+  REQUIRED: 'REQUIRED', // client needs to provide the registrationId by calling verifyRegistrationId() before calling join()
+  UNKNOWN: 'UNKNOWN', // we are waiting for information from the backend if registrationId is required or not
+  VERIFIED: 'VERIFIED', // client has already provided the registrationId and it has been verified, client can proceed to call join()
+};
+
 export const MEETING_INFO_FAILURE_REASON = {
   NONE: 'NONE', // meeting info was retrieved succesfully
   WRONG_PASSWORD: 'WRONG_PASSWORD', // meeting requires password and no password or wrong one was provided
   WRONG_CAPTCHA: 'WRONG_CAPTCHA', // wbxappapi requires a captcha code or a wrong captcha code was provided
+  WRONG_REGISTRATION_ID: 'WRONG_REGISTRATION_ID', // meeting requires registrationId and no registrationId or wrong one was provided
   POLICY: 'POLICY', // meeting info request violates some meeting policy
   WEBINAR_REGISTRATION: 'WEBINAR_REGISTRATION', // webinar need registration
+  NEED_JOIN_WITH_WEBCAST: 'NEED_JOIN_WITH_WEBCAST', // webinar need using webcast join
+  WEBINAR_NEED_REGISTRATION_ID: 'WEBINAR_NEED_REGISTRATION_ID', // webinar need registrationID
+  NOT_REACH_JBH: 'NOT_REACH_JBH', // Meeting is not allow to access since not reach JBH (join before host) time
+  JOIN_FORBIDDEN: 'JOIN_FORBIDDEN', // meeting is not allow join
   OTHER: 'OTHER', // any other error (network, etc)
 };
 
@@ -1359,3 +1408,12 @@ export const DESTINATION_TYPE = {
 } as const;
 
 export type DESTINATION_TYPE = Enum<typeof DESTINATION_TYPE>;
+
+export const INITIAL_REGISTRATION_STATUS = {
+  fetchWebexSite: false,
+  getGeoHint: false,
+  startReachability: false,
+  deviceRegister: false,
+  mercuryConnect: false,
+  checkH264Support: false,
+};

package/src/index.ts

@@ -8,7 +8,7 @@ import CaptchaError from './common/errors/captcha-error';
 import IntentToJoinError from './common/errors/intent-to-join';
 import PasswordError from './common/errors/password-error';
 import PermissionError from './common/errors/permission';
-import WebinarRegistrationError from './common/errors/webinar-registration-error';
+import JoinWebinarError from './common/errors/join-webinar-error';
 import {
   ReclaimHostEmptyWrongKeyError,
   ReclaimHostIsHostAlreadyError,
@@ -27,7 +27,6 @@ registerPlugin('meetings', Meetings, {
 });
 
 export {
-  getDevices,
   LocalStream,
   LocalDisplayStream,
   LocalSystemAudioStream,
@@ -41,12 +40,15 @@ export {
   LocalCameraStream,
   createMicrophoneStream,
   createCameraStream,
+  createCameraAndMicrophoneStreams,
   createDisplayStream,
   createDisplayStreamWithAudio,
+  createDisplayMedia,
   FacingMode,
   DisplaySurface,
   PresetCameraConstraints,
   type VideoContentHint,
+  type StreamState,
 } from '@webex/media-helpers';
 
 export default Meetings;
@@ -69,7 +71,7 @@ export {
   ReclaimHostEmptyWrongKeyError,
   Meeting,
   MeetingInfoUtil,
-  WebinarRegistrationError,
+  JoinWebinarError,
 };
 
 export {RemoteMedia} from './multistream/remoteMedia';

package/src/locus-info/index.ts

@@ -10,6 +10,7 @@ import {
   _SIP_BRIDGE_,
   MEETING_STATE,
   _MEETING_,
+  _SPACE_SHARE_,
   LOCUSINFO,
   LOCUS,
   _LEFT_,
@@ -489,7 +490,8 @@ export default class LocusInfo extends EventsScope {
   isMeetingActive() {
     if (
       this.parsedLocus.fullState.type === _CALL_ ||
-      this.parsedLocus.fullState.type === _SIP_BRIDGE_
+      this.parsedLocus.fullState.type === _SIP_BRIDGE_ ||
+      this.parsedLocus.fullState.type === _SPACE_SHARE_
     ) {
       // @ts-ignore
       const partner = this.getLocusPartner(this.participants, this.self);
@@ -1283,12 +1285,13 @@ export default class LocusInfo extends EventsScope {
   /**
    * handles when the locus.mediaShares is updated
    * @param {Object} mediaShares the locus.mediaShares property
+   * @param {boolean} forceUpdate force to update the mediaShares
    * @returns {undefined}
    * @memberof LocusInfo
    * emits internal event locus_info_update_media_shares
    */
-  updateMediaShares(mediaShares: object) {
-    if (mediaShares && !isEqual(this.mediaShares, mediaShares)) {
+  updateMediaShares(mediaShares: object, forceUpdate = false) {
+    if (mediaShares && (!isEqual(this.mediaShares, mediaShares) || forceUpdate)) {
       const parsedMediaShares = MediaSharesUtils.getMediaShares(this.mediaShares, mediaShares);
 
       this.updateMeeting(parsedMediaShares.current);
@@ -1303,6 +1306,7 @@ export default class LocusInfo extends EventsScope {
         {
           current: parsedMediaShares.current,
           previous: parsedMediaShares.previous,
+          forceUpdate,
         }
       );
     }
@@ -1393,6 +1397,19 @@ export default class LocusInfo extends EventsScope {
         );
       }
 
+      if (parsedSelves.updates.brbChanged) {
+        this.emitScoped(
+          {
+            file: 'locus-info',
+            function: 'updateSelf',
+          },
+          LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,
+          {
+            brb: parsedSelves.current.brb,
+          }
+        );
+      }
+
       if (parsedSelves.updates.interpretationChanged) {
         this.emitScoped(
           {

package/src/locus-info/selfUtils.ts

@@ -66,6 +66,7 @@ SelfUtils.parse = (self: any, deviceId: string) => {
       breakoutSessions: SelfUtils.getBreakoutSessions(self),
       breakout: SelfUtils.getBreakout(self),
       interpretation: SelfUtils.getInterpretation(self),
+      brb: SelfUtils.getBrb(self),
     };
   }
 
@@ -75,6 +76,7 @@ SelfUtils.parse = (self: any, deviceId: string) => {
 SelfUtils.getBreakoutSessions = (self) => self?.controls?.breakout?.sessions;
 SelfUtils.getBreakout = (self) => self?.controls?.breakout;
 SelfUtils.getInterpretation = (self) => self?.controls?.interpretation;
+SelfUtils.getBrb = (self) => self?.controls?.brb;
 
 SelfUtils.getLayout = (self) =>
   Array.isArray(self?.controls?.layouts) ? self.controls.layouts[0].type : undefined;
@@ -97,7 +99,7 @@ SelfUtils.getSelves = (oldSelf, newSelf, deviceId) => {
   const current = newSelf && SelfUtils.parse(newSelf, deviceId);
   const updates: any = {};
 
-  updates.isUserUnadmitted = SelfUtils.isUserUnadmitted(current);
+  updates.isUserUnadmitted = SelfUtils.isUserUnadmitted(previous, current);
   updates.isUserAdmitted = SelfUtils.isUserAdmitted(previous, current);
   updates.isVideoMutedByOthersChanged = SelfUtils.videoMutedByOthersChanged(previous, current);
   updates.isMutedByOthersChanged = SelfUtils.mutedByOthersChanged(previous, current);
@@ -128,6 +130,7 @@ SelfUtils.getSelves = (oldSelf, newSelf, deviceId) => {
   updates.isSharingBlockedChanged = previous?.isSharingBlocked !== current.isSharingBlocked;
   updates.breakoutsChanged = SelfUtils.breakoutsChanged(previous, current);
   updates.interpretationChanged = SelfUtils.interpretationChanged(previous, current);
+  updates.brbChanged = SelfUtils.brbChanged(previous, current);
 
   return {
     previous,
@@ -159,6 +162,9 @@ SelfUtils.breakoutsChanged = (previous, current) =>
 SelfUtils.interpretationChanged = (previous, current) =>
   !isEqual(previous?.interpretation, current?.interpretation) && !!current?.interpretation;
 
+SelfUtils.brbChanged = (previous, current) =>
+  !isEqual(previous?.brb, current?.brb) && current?.brb !== undefined;
+
 SelfUtils.isMediaInactive = (previous, current) => {
   if (
     previous &&
@@ -324,16 +330,23 @@ SelfUtils.isLocusUserAdmitted = (check: any) =>
   check && check.joinedWith?.intent?.type !== _WAIT_ && check.state === _JOINED_;
 
 /**
- * @param {Object} self
+ * @param {Object} oldSelf
+ * @param {Object} changedSelf
  * @returns {Boolean}
  * @throws {Error} when self is undefined
  */
-SelfUtils.isUserUnadmitted = (self: object) => {
-  if (!self) {
-    throw new ParameterError('self must be defined to determine if self is unadmitted as guest.');
+SelfUtils.isUserUnadmitted = (oldSelf: object, changedSelf: object) => {
+  if (!changedSelf) {
+    throw new ParameterError(
+      'changedSelf must be defined to determine if self is unadmitted as guest.'
+    );
   }
 
-  return SelfUtils.isLocusUserUnadmitted(self);
+  if (SelfUtils.isLocusUserUnadmitted(oldSelf)) {
+    return false;
+  }
+
+  return SelfUtils.isLocusUserUnadmitted(changedSelf);
 };
 
 SelfUtils.moderatorChanged = (oldSelf, changedSelf) => {
@@ -428,6 +441,11 @@ SelfUtils.mutedByOthersChanged = (oldSelf, changedSelf) => {
     return false;
   }
 
+  // there is no need to trigger user update if no one muted user
+  if (changedSelf.selfIdentity === changedSelf.modifiedBy) {
+    return false;
+  }
+
   return (
     changedSelf.remoteMuted !== null &&
     (oldSelf.remoteMuted !== changedSelf.remoteMuted ||

package/src/media/MediaConnectionAwaiter.ts

@@ -111,6 +111,8 @@ export default class MediaConnectionAwaiter {
 
     this.clearCallbacks();
 
+    LoggerProxy.logger.warn('Media:MediaConnectionAwaiter#connectionStateChange --> Resolving');
+
     this.defer.resolve();
   }
 

package/src/media/properties.ts

@@ -287,24 +287,45 @@ export default class MediaProperties {
     selectedCandidatePairChanges: number;
     numTransports: number;
   }> {
-    const allStatsReports = [];
-
     try {
-      const statsResult = await this.webrtcMediaConnection.getStats();
-      statsResult.forEach((report) => allStatsReports.push(report));
+      const allStatsReports = [];
+
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error('timed out'));
+        }, 1000);
+
+        this.webrtcMediaConnection
+          .getStats()
+          .then((statsResult) => {
+            clearTimeout(timeout);
+            statsResult.forEach((report) => allStatsReports.push(report));
+            resolve(allStatsReports);
+          })
+          .catch((error) => {
+            clearTimeout(timeout);
+            reject(error);
+          });
+      });
+
+      const connectionType = this.getConnectionType(allStatsReports);
+      const {selectedCandidatePairChanges, numTransports} = this.getTransportInfo(allStatsReports);
+
+      return {
+        connectionType,
+        selectedCandidatePairChanges,
+        numTransports,
+      };
     } catch (error) {
       LoggerProxy.logger.warn(
         `Media:properties#getCurrentConnectionInfo --> getStats() failed: ${error}`
       );
-    }
-
-    const connectionType = this.getConnectionType(allStatsReports);
-    const {selectedCandidatePairChanges, numTransports} = this.getTransportInfo(allStatsReports);
 
-    return {
-      connectionType,
-      selectedCandidatePairChanges,
-      numTransports,
-    };
+      return {
+        connectionType: 'unknown',
+        selectedCandidatePairChanges: -1,
+        numTransports: 0,
+      };
+    }
   }
 }

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;
+  }
+}