@webex/plugin-meetings 3.7.0-wxcc.1 → 3.8.0-next.1

package/package.json

@@ -43,13 +43,13 @@
     "@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-wxcc.1",
-    "@webex/plugin-rooms": "3.7.0-wxcc.1",
-    "@webex/test-helper-chai": "3.7.0-wxcc.1",
-    "@webex/test-helper-mocha": "3.7.0-wxcc.1",
-    "@webex/test-helper-mock-webex": "3.7.0-wxcc.1",
-    "@webex/test-helper-retry": "3.7.0-wxcc.1",
-    "@webex/test-helper-test-users": "3.7.0-wxcc.1",
+    "@webex/plugin-meetings": "3.8.0-next.1",
+    "@webex/plugin-rooms": "3.7.0-next.25",
+    "@webex/test-helper-chai": "3.7.0-next.18",
+    "@webex/test-helper-mocha": "3.7.0-next.18",
+    "@webex/test-helper-mock-webex": "3.7.0-next.18",
+    "@webex/test-helper-retry": "3.7.0-next.18",
+    "@webex/test-helper-test-users": "3.7.0-next.18",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "eslint": "^8.24.0",
@@ -61,22 +61,22 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.7.0-wxcc.1",
-    "@webex/event-dictionary-ts": "^1.0.1643",
-    "@webex/internal-media-core": "2.14.2",
-    "@webex/internal-plugin-conversation": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-device": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-llm": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-mercury": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-metrics": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-support": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-user": "3.7.0-wxcc.1",
-    "@webex/internal-plugin-voicea": "3.7.0-wxcc.1",
-    "@webex/media-helpers": "3.7.0-wxcc.1",
-    "@webex/plugin-people": "3.7.0-wxcc.1",
-    "@webex/plugin-rooms": "3.7.0-wxcc.1",
+    "@webex/common": "3.7.0-next.18",
+    "@webex/event-dictionary-ts": "^1.0.1688",
+    "@webex/internal-media-core": "2.14.4",
+    "@webex/internal-plugin-conversation": "3.7.0-next.25",
+    "@webex/internal-plugin-device": "3.7.0-next.18",
+    "@webex/internal-plugin-llm": "3.8.0-next.1",
+    "@webex/internal-plugin-mercury": "3.7.0-next.23",
+    "@webex/internal-plugin-metrics": "3.7.0-next.18",
+    "@webex/internal-plugin-support": "3.7.0-next.26",
+    "@webex/internal-plugin-user": "3.7.0-next.18",
+    "@webex/internal-plugin-voicea": "3.8.0-next.1",
+    "@webex/media-helpers": "3.7.0-next.25",
+    "@webex/plugin-people": "3.7.0-next.23",
+    "@webex/plugin-rooms": "3.7.0-next.25",
     "@webex/web-capabilities": "^1.4.0",
-    "@webex/webex-core": "3.7.0-wxcc.1",
+    "@webex/webex-core": "3.7.0-next.18",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
@@ -92,5 +92,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.7.0-wxcc.1"
+  "version": "3.8.0-next.1"
 }

package/src/constants.ts

@@ -202,7 +202,7 @@ 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_REGISTRATIONID = [403037, 403137];
+export const WEBINAR_ERROR_REGISTRATION_ID = [403037, 403137];
 export const JOIN_BEFORE_HOST = 403003;
 
 // ******************** REGEX **********************
@@ -1331,14 +1331,22 @@ 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_REGISTRATIONID: 'WEBINAR_NEED_REGISTRATIONID', // webinar need registrationID
+  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)

package/src/locus-info/selfUtils.ts

@@ -441,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;
+  }
+}

package/src/meeting/index.ts

@@ -122,8 +122,9 @@ import {
   ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT,
   NAMED_MEDIA_GROUP_TYPE_AUDIO,
   WEBINAR_ERROR_WEBCAST,
-  WEBINAR_ERROR_REGISTRATIONID,
+  WEBINAR_ERROR_REGISTRATION_ID,
   JOIN_BEFORE_HOST,
+  REGISTRATION_ID_STATUS,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ParameterError from '../common/errors/parameter';
@@ -163,6 +164,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';
 
@@ -255,6 +257,7 @@ export enum ScreenShareFloorStatus {
 
 type FetchMeetingInfoParams = {
   password?: string;
+  registrationId?: string;
   captchaCode?: string;
   extraParams?: Record<string, any>;
   sendCAevents?: boolean;
@@ -649,6 +652,8 @@ export default class Meeting extends StatelessWebexPlugin {
   turnServerUsed: boolean;
   areVoiceaEventsSetup = false;
   isMoveToInProgress = false;
+  registrationIdStatus: string;
+  brbState: BrbState;
 
   voiceaListenerCallbacks: object = {
     [VOICEAEVENTS.VOICEA_ANNOUNCEMENT]: (payload: Transcription['languageOptions']) => {
@@ -1345,6 +1350,16 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.passwordStatus = PASSWORD_STATUS.UNKNOWN;
 
+    /**
+     * registrationId status. If it's REGISTRATIONID_STATUS.REQUIRED then verifyRegistrationId() needs to be called
+     * with the correct registrationId before calling join()
+     * @instance
+     * @type {REGISTRATION_ID_STATUS}
+     * @public
+     * @memberof Meeting
+     */
+    this.registrationIdStatus = REGISTRATION_ID_STATUS.UNKNOWN;
+
     /**
      * Information about required captcha. If null, then no captcha is required. status. If it's PASSWORD_STATUS.REQUIRED then verifyPassword() needs to be called
      * with the correct password before calling join()
@@ -1657,6 +1672,15 @@ export default class Meeting extends StatelessWebexPlugin {
       this.passwordStatus = PASSWORD_STATUS.NOT_REQUIRED;
     }
 
+    if (
+      this.registrationIdStatus === REGISTRATION_ID_STATUS.REQUIRED ||
+      this.registrationIdStatus === REGISTRATION_ID_STATUS.VERIFIED
+    ) {
+      this.registrationIdStatus = REGISTRATION_ID_STATUS.VERIFIED;
+    } else {
+      this.registrationIdStatus = REGISTRATION_ID_STATUS.NOT_REQUIRED;
+    }
+
     Trigger.trigger(
       this,
       {
@@ -1700,7 +1724,12 @@ export default class Meeting extends StatelessWebexPlugin {
    * @private
    */
   private prepForFetchMeetingInfo(
-    {password = null, captchaCode = null, extraParams = {}}: FetchMeetingInfoParams,
+    {
+      password = null,
+      registrationId = null,
+      captchaCode = null,
+      extraParams = {},
+    }: FetchMeetingInfoParams,
     caller: string
   ): Promise<void> {
     // when fetch meeting info is called directly by the client, we want to clear out the random timer for sdk to do it
@@ -1740,6 +1769,7 @@ export default class Meeting extends StatelessWebexPlugin {
     captchaCode = null,
     extraParams = {},
     sendCAevents = false,
+    registrationId = null,
   }): Promise<void> {
     try {
       const captchaInfo = captchaCode
@@ -1755,7 +1785,8 @@ export default class Meeting extends StatelessWebexPlugin {
         this.config.installedOrgID,
         this.locusId,
         extraParams,
-        {meetingId: this.id, sendCAevents}
+        {meetingId: this.id, sendCAevents},
+        registrationId
       );
 
       this.parseMeetingInfo(info?.body, this.destination, info?.errors);
@@ -1777,14 +1808,15 @@ export default class Meeting extends StatelessWebexPlugin {
         this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WEBINAR_REGISTRATION;
         if (WEBINAR_ERROR_WEBCAST.includes(err.wbxAppApiCode)) {
           this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.NEED_JOIN_WITH_WEBCAST;
-        } else if (WEBINAR_ERROR_REGISTRATIONID.includes(err.wbxAppApiCode)) {
-          this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WEBINAR_NEED_REGISTRATIONID;
+        } else if (WEBINAR_ERROR_REGISTRATION_ID.includes(err.wbxAppApiCode)) {
+          this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WEBINAR_NEED_REGISTRATION_ID;
         }
         this.meetingInfoFailureCode = err.wbxAppApiCode;
 
         if (err.meetingInfo) {
           this.meetingInfo = err.meetingInfo;
         }
+        this.requiredCaptcha = null;
 
         throw new JoinWebinarError();
       } else if (err instanceof MeetingInfoV2JoinForbiddenError) {
@@ -1829,9 +1861,13 @@ export default class Meeting extends StatelessWebexPlugin {
           `Meeting:index#fetchMeetingInfo --> Info Unable to fetch meeting info for ${this.destination} - captcha required (code=${err?.body?.code}).`
         );
 
-        this.meetingInfoFailureReason = this.requiredCaptcha
-          ? MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA
-          : MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD;
+        if (this.requiredCaptcha) {
+          this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA;
+        } else if (err.isRegistrationIdRequired) {
+          this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WRONG_REGISTRATION_ID;
+        } else {
+          this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD;
+        }
 
         this.meetingInfoFailureCode = err.wbxAppApiCode;
 
@@ -1839,6 +1875,10 @@ export default class Meeting extends StatelessWebexPlugin {
           this.passwordStatus = PASSWORD_STATUS.REQUIRED;
         }
 
+        if (err.isRegistrationIdRequired) {
+          this.registrationIdStatus = REGISTRATION_ID_STATUS.REQUIRED;
+        }
+
         this.requiredCaptcha = err.captchaInfo;
         throw new CaptchaError();
       } else {
@@ -1979,6 +2019,48 @@ export default class Meeting extends StatelessWebexPlugin {
       });
   }
 
+  /**
+   * Checks if the supplied registrationId is correct. It returns a promise with information whether the
+   * registrationId and captcha code were correct or not.
+   * @param {String | undefined} registrationId - can be undefined if only captcha was required
+   * @param {String | undefined} captchaCode - can be undefined if captcha was not required by the server
+   * @param {Boolean} sendCAevents - whether Call Analyzer events should be sent when fetching meeting information
+   * @public
+   * @memberof Meeting
+   * @returns {Promise<{isRegistrationIdValid: boolean, requiredCaptcha: boolean, failureReason: MEETING_INFO_FAILURE_REASON}>}
+   */
+  public verifyRegistrationId(registrationId: string, captchaCode: string, sendCAevents = false) {
+    return this.fetchMeetingInfo({
+      registrationId,
+      captchaCode,
+      sendCAevents,
+    })
+      .then(() => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.VERIFY_REGISTRATION_ID_SUCCESS);
+
+        return {
+          isRegistrationIdValid: true,
+          requiredCaptcha: null,
+          failureReason: MEETING_INFO_FAILURE_REASON.NONE,
+        };
+      })
+      .catch((error) => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.VERIFY_REGISTRATION_ID_ERROR);
+
+        if (error instanceof JoinWebinarError || error instanceof CaptchaError) {
+          return {
+            isRegistrationIdValid: this.registrationIdStatus === REGISTRATION_ID_STATUS.VERIFIED,
+            requiredCaptcha: this.requiredCaptcha,
+            failureReason:
+              error instanceof JoinWebinarError
+                ? MEETING_INFO_FAILURE_REASON.WRONG_REGISTRATION_ID
+                : this.meetingInfoFailureReason,
+          };
+        }
+        throw error;
+      });
+  }
+
   /**
    * Refreshes the captcha. As a result the meeting will have new captcha id, image and audio.
    * If the refresh operation fails, meeting remains with the old captcha properties.
@@ -3349,6 +3431,10 @@ export default class Meeting extends StatelessWebexPlugin {
     // The second on is if the audio is muted, we need to tell the statsAnalyzer when
     // the audio is muted or the user is not willing to send media
     this.locusInfo.on(LOCUSINFO.EVENTS.MEDIA_STATUS_CHANGE, (status) => {
+      LoggerProxy.logger.info(
+        'Meeting:index#setUpLocusInfoSelfListener --> MEDIA_STATUS_CHANGE received, processing...'
+      );
+
       if (this.statsAnalyzer) {
         this.statsAnalyzer.updateMediaStatus({
           actual: status,
@@ -3362,6 +3448,10 @@ export default class Meeting extends StatelessWebexPlugin {
             receiveShare: this.mediaProperties.mediaDirection?.receiveShare,
           },
         });
+      } else {
+        LoggerProxy.logger.warn(
+          'Meeting:index#setUpLocusInfoSelfListener --> MEDIA_STATUS_CHANGE, statsAnalyzer is not available.'
+        );
       }
     });
 
@@ -3407,6 +3497,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 +3741,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);
   }
 
   /**
@@ -5718,7 +5794,14 @@ export default class Meeting extends StatelessWebexPlugin {
         return undefined;
       }
       // @ts-ignore - Fix type
-      await this.webex.internal.llm.disconnectLLM();
+      await this.webex.internal.llm.disconnectLLM(
+        isJoined
+          ? {
+              code: 3050,
+              reason: 'done (permanent)',
+            }
+          : undefined
+      );
       // @ts-ignore - Fix type
       this.webex.internal.llm.off('event:relay.event', this.processRelayEvent);
     }
@@ -6099,9 +6182,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`
       );
@@ -6716,6 +6802,9 @@ export default class Meeting extends StatelessWebexPlugin {
         new RtcMetrics(this.webex, {meetingId: this.id}, this.correlationId)
       : undefined;
 
+    // ongoing reachability checks slow down new media connections especially on Firefox, so we stop them
+    this.getWebexObject().meetings.reachability.stopReachability();
+
     const mc = Media.createMediaConnection(
       this.isMultistream,
       this.getMediaConnectionDebugId(),
@@ -7432,6 +7521,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);
@@ -7467,6 +7557,9 @@ export default class Meeting extends StatelessWebexPlugin {
           throw error;
         }
       }
+
+      LoggerProxy.logger.info(`${LOG_HEADER} media connected, finalizing...`);
+
       if (this.mediaProperties.hasLocalShareStream()) {
         await this.enqueueScreenShareFloorRequest();
       }

package/src/meeting/muteState.ts

@@ -379,12 +379,7 @@ export class MuteState {
     }
     if (muted !== undefined) {
       this.state.server.remoteMute = muted;
-
-      // We never want to unmute the local stream from a server remote mute update.
-      // Moderated unmute is handled by a different function.
-      if (muted) {
-        this.muteLocalStream(meeting, muted, 'remotelyMuted');
-      }
+      this.muteLocalStream(meeting, muted, 'remotelyMuted');
     }
   }