@webex/plugin-meetings 3.0.0-beta.16 → 3.0.0-beta.161

package/src/meeting/index.ts

@@ -1,12 +1,29 @@
 import uuid from 'uuid';
-import {cloneDeep, isEqual, pick, isString, defer} from 'lodash';
+import {cloneDeep, isEqual, pick, defer, isEmpty} from 'lodash';
 // @ts-ignore - Fix this
 import {StatelessWebexPlugin} from '@webex/webex-core';
-import {Media as WebRTCMedia, MediaConnection as MC} from '@webex/internal-media-core';
+import {
+  ConnectionState,
+  Errors,
+  ErrorType,
+  Event,
+  MediaContent,
+  MediaType,
+  RemoteTrackType,
+} from '@webex/internal-media-core';
+
+import {
+  getDevices,
+  LocalTrack,
+  LocalCameraTrack,
+  LocalDisplayTrack,
+  LocalMicrophoneTrack,
+  LocalTrackEvents,
+  TrackMuteEvent,
+} from '@webex/media-helpers';
 
 import {
   MeetingNotActiveError,
-  createMeetingsError,
   UserInLobbyError,
   NoMediaEstablishedYetError,
   UserNotJoinedError,
@@ -16,20 +33,22 @@ import NetworkQualityMonitor from '../networkQualityMonitor';
 import LoggerProxy from '../common/logs/logger-proxy';
 import Trigger from '../common/events/trigger-proxy';
 import Roap from '../roap/index';
-import Media from '../media';
+import Media, {type BundlePolicy} from '../media';
 import MediaProperties from '../media/properties';
 import MeetingStateMachine from './state';
-import createMuteState from './muteState';
-import createEffectsState from './effectsState';
+import {createMuteState} from './muteState';
 import LocusInfo from '../locus-info';
 import Metrics from '../metrics';
-import {trigger, mediaType, error as MetricsError, eventType} from '../metrics/config';
+import {trigger, error as MetricsError, eventType} from '../metrics/config';
 import ReconnectionManager from '../reconnection-manager';
 import MeetingRequest from './request';
 import Members from '../members/index';
 import MeetingUtil from './util';
+import RecordingUtil from '../recording-controller/util';
+import ControlsOptionsUtil from '../controls-options-manager/util';
 import MediaUtil from '../media/util';
 import Transcription from '../transcription';
+import {Reactions, SkinTones} from '../reactions/reactions';
 import PasswordError from '../common/errors/password-error';
 import CaptchaError from '../common/errors/captcha-error';
 import ReconnectionError from '../common/errors/reconnection';
@@ -40,10 +59,12 @@ import {
   _JOIN_,
   AUDIO,
   CONTENT,
+  DISPLAY_HINTS,
   ENDED,
   EVENT_TRIGGERS,
   EVENT_TYPES,
   EVENTS,
+  BREAKOUTS,
   FLOOR_ACTION,
   FULL_STATE,
   LAYOUT_TYPES,
@@ -64,53 +85,85 @@ import {
   RECORDING_STATE,
   SHARE_STATUS,
   SHARE_STOPPED_REASON,
-  VIDEO_RESOLUTIONS,
   VIDEO,
-  BNR_STATUS,
   HTTP_VERBS,
+  SELF_ROLES,
+  INTERPRETATION,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ParameterError from '../common/errors/parameter';
-import MediaError from '../common/errors/media';
 import {
   MeetingInfoV2PasswordError,
   MeetingInfoV2CaptchaError,
+  MeetingInfoV2PolicyError,
 } from '../meeting-info/meeting-info-v2';
 import BrowserDetection from '../common/browser-detection';
-import {ReceiveSlotManager} from '../multistream/receiveSlotManager';
+import {CSI, ReceiveSlotManager} from '../multistream/receiveSlotManager';
 import {MediaRequestManager} from '../multistream/mediaRequestManager';
 import {
+  Configuration as RemoteMediaManagerConfiguration,
   RemoteMediaManager,
   Event as RemoteMediaManagerEvent,
 } from '../multistream/remoteMediaManager';
-import {MultistreamMedia} from '../multistream/multistreamMedia';
-import {SkinTones, Reactions} from '../reactions/reactions';
-import {Reaction, ReactionType, SkinToneType} from '../reactions/reactions.type';
+import {
+  Reaction,
+  ReactionServerType,
+  SkinToneType,
+  ProcessedReaction,
+  RelayEvent,
+} from '../reactions/reactions.type';
+import Breakouts from '../breakouts';
+import SimultaneousInterpretation from '../interpretation';
+import Annotation from '../annotation';
 
 import InMeetingActions from './in-meeting-actions';
+import {REACTION_RELAY_TYPES} from '../reactions/constants';
+import RecordingController from '../recording-controller';
+import ControlsOptionsManager from '../controls-options-manager';
+import PermissionError from '../common/errors/permission';
+import {LocusMediaRequest} from './locusMediaRequest';
+import {AnnotationInfo} from '../annotation/annotation.types';
 
 const {isBrowser} = BrowserDetection();
 
-const logRequest = (request: any, {header = '', success = '', failure = ''}) => {
-  LoggerProxy.logger.info(header);
+const logRequest = (request: any, {logText = ''}) => {
+  LoggerProxy.logger.info(`${logText} - sending request`);
 
   return request
     .then((arg) => {
-      LoggerProxy.logger.info(success);
+      LoggerProxy.logger.info(`${logText} - has been successfully sent`);
 
       return arg;
     })
     .catch((error) => {
-      LoggerProxy.logger.error(failure, error);
+      LoggerProxy.logger.error(`${logText} - has failed: `, error);
       throw error;
     });
 };
 
+export type LocalTracks = {
+  microphone?: LocalMicrophoneTrack;
+  camera?: LocalCameraTrack;
+  screenShare?: {
+    audio?: LocalTrack; // todo: for now screen share audio is not supported (will be done in SPARK-399690)
+    video?: LocalDisplayTrack;
+  };
+  annotationInfo?: AnnotationInfo;
+};
+
+export type AddMediaOptions = {
+  localTracks?: LocalTracks;
+  audioEnabled?: boolean; // if not specified, default value true is used
+  videoEnabled?: boolean; // if not specified, default value true is used
+  receiveShare?: boolean; // if not specified, default value true is used
+  remoteMediaManagerConfig?: RemoteMediaManagerConfiguration; // applies only to multistream meetings
+  bundlePolicy?: BundlePolicy; // applies only to multistream meetings
+};
+
 export const MEDIA_UPDATE_TYPE = {
-  ALL: 'ALL',
-  AUDIO: 'AUDIO',
-  VIDEO: 'VIDEO',
-  SHARE: 'SHARE',
+  TRANSCODED_MEDIA_CONNECTION: 'TRANSCODED_MEDIA_CONNECTION',
+  SHARE_FLOOR_REQUEST: 'SHARE_FLOOR_REQUEST',
+  UPDATE_MEDIA: 'UPDATE_MEDIA',
 };
 
 /**
@@ -125,16 +178,6 @@ export const MEDIA_UPDATE_TYPE = {
  * @property {boolean} isSharing
  */
 
-/**
- * AudioVideo
- * @typedef {Object} AudioVideo
- * @property {Object} audio
- * @property {String} audio.deviceId
- * @property {Object} video
- * @property {String} video.deviceId
- * @property {String} video.localVideoQuality // [240p, 360p, 480p, 720p, 1080p]
- */
-
 /**
  * SharePreferences
  * @typedef {Object} SharePreferences
@@ -149,18 +192,10 @@ export const MEDIA_UPDATE_TYPE = {
  * @property {String} [pin]
  * @property {Boolean} [moderator]
  * @property {String|Object} [meetingQuality]
- * @property {String} [meetingQuality.local]
  * @property {String} [meetingQuality.remote]
  * @property {Boolean} [rejoin]
  * @property {Boolean} [enableMultistream]
- */
-
-/**
- * SendOptions
- * @typedef {Object} SendOptions
- * @property {Boolean} sendAudio
- * @property {Boolean} sendVideo
- * @property {Boolean} sendShare
+ * @property {String} [correlationId]
  */
 
 /**
@@ -403,12 +438,14 @@ export const MEDIA_UPDATE_TYPE = {
 export default class Meeting extends StatelessWebexPlugin {
   attrs: any;
   audio: any;
+  breakouts: any;
+  simultaneousInterpretation: any;
+  annotation: any;
   conversationUrl: string;
   correlationId: string;
   destination: string;
   destinationType: string;
   deviceUrl: string;
-  effects: any;
   hostId: string;
   id: string;
   isMultistream: boolean;
@@ -416,7 +453,7 @@ export default class Meeting extends StatelessWebexPlugin {
   mediaConnections: any[];
   mediaId?: string;
   meetingFiniteStateMachine: any;
-  meetingInfo: object;
+  meetingInfo: any;
   meetingRequest: MeetingRequest;
   members: Members;
   options: object;
@@ -428,6 +465,7 @@ export default class Meeting extends StatelessWebexPlugin {
   resource: string;
   roap: Roap;
   roapSeq: number;
+  selfUrl?: string; // comes from Locus, initialized by updateMeetingObject()
   sipUri: string;
   type: string;
   userId: string;
@@ -449,32 +487,37 @@ export default class Meeting extends StatelessWebexPlugin {
   keepAliveTimerId: NodeJS.Timeout;
   lastVideoLayoutInfo: any;
   locusInfo: any;
-  media: MultistreamMedia;
+  locusMediaRequest?: LocusMediaRequest;
   mediaProperties: MediaProperties;
   mediaRequestManagers: {
     audio: MediaRequestManager;
     video: MediaRequestManager;
+    screenShareAudio: MediaRequestManager;
+    screenShareVideo: MediaRequestManager;
   };
 
   meetingInfoFailureReason: string;
+  meetingInfoFailureCode?: number;
   networkQualityMonitor: NetworkQualityMonitor;
   networkStatus: string;
   passwordStatus: string;
   queuedMediaUpdates: any[];
   recording: any;
   remoteMediaManager: RemoteMediaManager | null;
+  recordingController: RecordingController;
+  controlsOptionsManager: ControlsOptionsManager;
   requiredCaptcha: any;
   receiveSlotManager: ReceiveSlotManager;
   shareStatus: string;
   statsAnalyzer: StatsAnalyzer;
   transcription: Transcription;
   updateMediaConnections: (mediaConnections: any[]) => void;
-  endCallInitiateJoinReq: any;
+  endCallInitJoinReq: any;
   endJoinReqResp: any;
   endLocalSDPGenRemoteSDPRecvDelay: any;
   joinedWith: any;
   locusId: any;
-  startCallInitiateJoinReq: any;
+  startCallInitJoinReq: any;
   startJoinReqResp: any;
   startLocalSDPGenRemoteSDPRecvDelay: any;
   wirelessShare: any;
@@ -487,8 +530,13 @@ export default class Meeting extends StatelessWebexPlugin {
   resourceUrl: string;
   selfId: string;
   state: any;
-
+  localAudioTrackMuteStateHandler: (event: TrackMuteEvent) => void;
+  localVideoTrackMuteStateHandler: (event: TrackMuteEvent) => void;
+  underlyingLocalTrackChangeHandler: () => void;
+  roles: any[];
+  environment: string;
   namespace = MEETINGS;
+  annotationInfo: AnnotationInfo;
 
   /**
    * @param {Object} attrs
@@ -523,7 +571,7 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.id = uuid.v4();
     /**
-     * Correlation ID used for network tracking of meeting join
+     * Correlation ID used for network tracking of meeting
      * @instance
      * @type {String}
      * @readonly
@@ -573,41 +621,132 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     // TODO: needs to be defined as a class
     this.meetingInfo = {};
+    /**
+     * @instance
+     * @type {Breakouts}
+     * @public
+     * @memberof Meeting
+     */
+    // @ts-ignore
+    this.breakouts = new Breakouts({meetingId: this.id}, {parent: this.webex});
+    /**
+     * @instance
+     * @type {SimultaneousInterpretation}
+     * @public
+     * @memberof Meeting
+     */
+    // @ts-ignore
+    this.simultaneousInterpretation = new SimultaneousInterpretation({}, {parent: this.webex});
+    /**
+     * @instance
+     * @type {Annotation}
+     * @public
+     * @memberof Meeting
+     */
+    // @ts-ignore
+    this.annotation = new Annotation({parent: this.webex});
     /**
      * helper class for managing receive slots (for multistream media connections)
      */
-    this.receiveSlotManager = new ReceiveSlotManager(this);
+    this.receiveSlotManager = new ReceiveSlotManager(
+      (mediaType: MediaType) => {
+        if (!this.mediaProperties?.webrtcMediaConnection) {
+          return Promise.reject(new Error('Webrtc media connection is missing'));
+        }
+
+        return this.mediaProperties.webrtcMediaConnection.createReceiveSlot(mediaType);
+      },
+      (csi: CSI) => (this.members.findMemberByCsi(csi) as any)?.id
+    );
     /**
-     * Helper class for managing media requests for main video (for multistream media connections)
-     * All media requests sent out for main video for this meeting have to go through it.
+     * Object containing helper classes for managing media requests for audio/video/screenshare (for multistream media connections)
+     * All multistream media requests sent out for this meeting have to go through them.
      */
     this.mediaRequestManagers = {
-      audio: new MediaRequestManager((mediaRequests) => {
-        if (!this.mediaProperties.webrtcMediaConnection) {
-          LoggerProxy.logger.warn(
-            'Meeting:index#mediaRequestManager --> trying to send audio media request before media connection was created'
+      audio: new MediaRequestManager(
+        (mediaRequests) => {
+          if (!this.mediaProperties.webrtcMediaConnection) {
+            LoggerProxy.logger.warn(
+              'Meeting:index#mediaRequestManager --> trying to send audio media request before media connection was created'
+            );
+
+            return;
+          }
+          this.mediaProperties.webrtcMediaConnection.requestMedia(
+            MediaType.AudioMain,
+            mediaRequests
           );
+        },
+        {
+          // @ts-ignore - config coming from registerPlugin
+          degradationPreferences: this.config.degradationPreferences,
+          kind: 'audio',
+          trimRequestsToNumOfSources: false,
+        }
+      ),
+      video: new MediaRequestManager(
+        (mediaRequests) => {
+          if (!this.mediaProperties.webrtcMediaConnection) {
+            LoggerProxy.logger.warn(
+              'Meeting:index#mediaRequestManager --> trying to send video media request before media connection was created'
+            );
 
-          return;
+            return;
+          }
+          this.mediaProperties.webrtcMediaConnection.requestMedia(
+            MediaType.VideoMain,
+            mediaRequests
+          );
+        },
+        {
+          // @ts-ignore - config coming from registerPlugin
+          degradationPreferences: this.config.degradationPreferences,
+          kind: 'video',
+          trimRequestsToNumOfSources: true,
         }
-        this.mediaProperties.webrtcMediaConnection.requestMedia(
-          MC.MediaType.AudioMain,
-          mediaRequests
-        );
-      }),
-      video: new MediaRequestManager((mediaRequests) => {
-        if (!this.mediaProperties.webrtcMediaConnection) {
-          LoggerProxy.logger.warn(
-            'Meeting:index#mediaRequestManager --> trying to send video media request before media connection was created'
+      ),
+      screenShareAudio: new MediaRequestManager(
+        (mediaRequests) => {
+          if (!this.mediaProperties.webrtcMediaConnection) {
+            LoggerProxy.logger.warn(
+              'Meeting:index#mediaRequestManager --> trying to send screenshare audio media request before media connection was created'
+            );
+
+            return;
+          }
+          this.mediaProperties.webrtcMediaConnection.requestMedia(
+            MediaType.AudioSlides,
+            mediaRequests
           );
+        },
+        {
+          // @ts-ignore - config coming from registerPlugin
+          degradationPreferences: this.config.degradationPreferences,
+          kind: 'audio',
+          trimRequestsToNumOfSources: false,
+        }
+      ),
+      screenShareVideo: new MediaRequestManager(
+        (mediaRequests) => {
+          if (!this.mediaProperties.webrtcMediaConnection) {
+            LoggerProxy.logger.warn(
+              'Meeting:index#mediaRequestManager --> trying to send screenshare video media request before media connection was created'
+            );
 
-          return;
+            return;
+          }
+          this.mediaProperties.webrtcMediaConnection.requestMedia(
+            MediaType.VideoSlides,
+            mediaRequests
+          );
+        },
+        {
+          // @ts-ignore - config coming from registerPlugin
+          degradationPreferences: this.config.degradationPreferences,
+          kind: 'video',
+          trimRequestsToNumOfSources: false,
         }
-        this.mediaProperties.webrtcMediaConnection.requestMedia(
-          MC.MediaType.VideoMain,
-          mediaRequests
-        );
-      }),
+      ),
     };
     /**
      * @instance
@@ -620,8 +759,9 @@ export default class Meeting extends StatelessWebexPlugin {
         locusUrl: attrs.locus && attrs.locus.url,
         receiveSlotManager: this.receiveSlotManager,
         mediaRequestManagers: this.mediaRequestManagers,
-        // @ts-ignore - Fix type
+        meeting: this,
       },
+      // @ts-ignore - Fix type
       {parent: this.webex}
     );
     /**
@@ -653,7 +793,7 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.reconnectionManager = new ReconnectionManager(this);
     /**
-     * created later
+     * created with media connection
      * @instance
      * @type {MuteState}
      * @private
@@ -661,21 +801,13 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.audio = null;
     /**
-     * created later
+     * created with media connection
      * @instance
      * @type {MuteState}
      * @private
      * @memberof Meeting
      */
     this.video = null;
-    /**
-     * created later
-     * @instance
-     * @type {EffectsState}
-     * @private
-     * @memberof Meeting
-     */
-    this.effects = null;
     /**
      * @instance
      * @type {MeetingStateMachine}
@@ -770,7 +902,12 @@ export default class Meeting extends StatelessWebexPlugin {
      * @private
      * @memberof Meeting
      */
-    this.meetingRequest = new MeetingRequest({}, options);
+    this.meetingRequest = new MeetingRequest(
+      {
+        meeting: this,
+      },
+      options
+    );
     /**
      * @instance
      * @type {Array}
@@ -924,6 +1061,7 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     // @ts-ignore - Fix type
     this.locusInfo = new LocusInfo(this.updateMeetingObject.bind(this), this.webex, this.id);
+
     // We had to add listeners first before setting up the locus instance
     /**
      * @instance
@@ -1014,6 +1152,15 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.meetingInfoFailureReason = undefined;
 
+    /**
+     * The numeric code, if any, associated with the last failure to obtain the meeting info
+     * @instance
+     * @type {number}
+     * @private
+     * @memberof Meeting
+     */
+    this.meetingInfoFailureCode = undefined;
+
     /**
      * Repeating timer used to send keepAlives when in lobby
      * @instance
@@ -1023,16 +1170,68 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.keepAliveTimerId = null;
 
+    /**
+     * The class that helps to control recording functions: start, stop, pause, resume, etc
+     * @instance
+     * @type {RecordingController}
+     * @public
+     * @memberof Meeting
+     */
+    this.recordingController = new RecordingController(this.meetingRequest, {
+      serviceUrl: this.locusInfo?.links?.services?.record?.url,
+      sessionId: this.locusInfo?.fullState?.sessionId,
+      locusUrl: this.locusInfo?.url,
+      displayHints: [],
+    });
+
+    /**
+     * The class that helps to control recording functions: start, stop, pause, resume, etc
+     * @instance
+     * @type {ControlsOptionsManager}
+     * @public
+     * @memberof Meeting
+     */
+    this.controlsOptionsManager = new ControlsOptionsManager(this.meetingRequest, {
+      locusUrl: this.locusInfo?.url,
+      displayHints: [],
+    });
+
     this.setUpLocusInfoListeners();
     this.locusInfo.init(attrs.locus ? attrs.locus : {});
     this.hasJoinedOnce = false;
 
-    this.media = new MultistreamMedia(this);
-
     /**
      * helper class for managing remote streams
      */
     this.remoteMediaManager = null;
+
+    this.localAudioTrackMuteStateHandler = (event) => {
+      this.audio.handleLocalTrackMuteStateChange(this, event.trackState.muted);
+    };
+
+    this.localVideoTrackMuteStateHandler = (event) => {
+      this.video.handleLocalTrackMuteStateChange(this, event.trackState.muted);
+    };
+
+    // The handling of underlying track changes should be done inside
+    // @webex/internal-media-core, but for now we have to do it here, because
+    // RoapMediaConnection has to use raw MediaStreamTracks in its API until
+    // the Calling SDK also moves to using webrtc-core tracks
+    this.underlyingLocalTrackChangeHandler = () => {
+      if (!this.isMultistream) {
+        this.updateTranscodedMediaConnection();
+      }
+    };
+  }
+
+  /**
+   * returns meeting is joined
+   * @private
+   * @memberof Meeting
+   * @returns {Boolean}
+   */
+  private isJoined() {
+    return this.joinedWith?.state === 'JOINED';
   }
 
   /**
@@ -1047,9 +1246,11 @@ export default class Meeting extends StatelessWebexPlugin {
   public async fetchMeetingInfo({
     password = null,
     captchaCode = null,
+    extraParams = {},
   }: {
     password?: string;
     captchaCode?: string;
+    extraParams?: Record<string, any>;
   }) {
     // when fetch meeting info is called directly by the client, we want to clear out the random timer for sdk to do it
     if (this.fetchMeetingInfoTimeoutId) {
@@ -1080,11 +1281,16 @@ export default class Meeting extends StatelessWebexPlugin {
         this.destination,
         this.destinationType,
         password,
-        captchaInfo
+        captchaInfo,
+        // @ts-ignore - config coming from registerPlugin
+        this.config.installedOrgID,
+        this.locusId,
+        extraParams,
+        {meetingId: this.id}
       );
 
       this.parseMeetingInfo(info, this.destination);
-      this.meetingInfo = info ? info.body : null;
+      this.meetingInfo = info ? {...info.body, meetingLookupUrl: info?.url} : null;
       this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.NONE;
       this.requiredCaptcha = null;
       if (
@@ -1107,9 +1313,18 @@ export default class Meeting extends StatelessWebexPlugin {
 
       return Promise.resolve();
     } catch (err) {
-      if (err instanceof MeetingInfoV2PasswordError) {
-        // @ts-ignore
+      if (err instanceof MeetingInfoV2PolicyError) {
+        this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.POLICY;
+        this.meetingInfoFailureCode = err.wbxAppApiCode;
+
+        if (err.meetingInfo) {
+          this.meetingInfo = err.meetingInfo;
+        }
+
+        throw new PermissionError();
+      } else if (err instanceof MeetingInfoV2PasswordError) {
         LoggerProxy.logger.info(
+          // @ts-ignore
           `Meeting:index#fetchMeetingInfo --> Info Unable to fetch meeting info for ${this.destination} - password required (code=${err?.body?.code}).`
         );
 
@@ -1119,6 +1334,8 @@ export default class Meeting extends StatelessWebexPlugin {
           this.meetingNumber = err.meetingInfo.meetingNumber;
         }
 
+        this.meetingInfoFailureCode = err.wbxAppApiCode;
+
         this.passwordStatus = PASSWORD_STATUS.REQUIRED;
         this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD;
         if (this.requiredCaptcha) {
@@ -1128,8 +1345,8 @@ export default class Meeting extends StatelessWebexPlugin {
 
         throw new PasswordError();
       } else if (err instanceof MeetingInfoV2CaptchaError) {
-        // @ts-ignore
         LoggerProxy.logger.info(
+          // @ts-ignore
           `Meeting:index#fetchMeetingInfo --> Info Unable to fetch meeting info for ${this.destination} - captcha required (code=${err?.body?.code}).`
         );
 
@@ -1137,6 +1354,8 @@ export default class Meeting extends StatelessWebexPlugin {
           ? MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA
           : MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD;
 
+        this.meetingInfoFailureCode = err.wbxAppApiCode;
+
         if (err.isPasswordRequired) {
           this.passwordStatus = PASSWORD_STATUS.REQUIRED;
         }
@@ -1201,22 +1420,39 @@ export default class Meeting extends StatelessWebexPlugin {
     // we have to pass the wbxappapi hostname as the siteFullName parameter
     const {hostname} = new URL(this.requiredCaptcha.refreshURL);
 
-    return this.meetingRequest
-      .refreshCaptcha({
-        captchaRefreshUrl: `${this.requiredCaptcha.refreshURL}&siteFullName=${hostname}`,
-        captchaId: this.requiredCaptcha.captchaId,
-      })
-      .then((response) => {
-        this.requiredCaptcha.captchaId = response.body.captchaID;
-        this.requiredCaptcha.verificationImageURL = response.body.verificationImageURL;
-        this.requiredCaptcha.verificationAudioURL = response.body.verificationAudioURL;
-      })
-      .catch((error) => {
-        LoggerProxy.logger.error(
-          `Meeting:index#refreshCaptcha --> Error Unable to refresh captcha for ${this.destination} - ${error}`
-        );
-        throw error;
-      });
+    return (
+      this.meetingRequest
+        // @ts-ignore
+        .refreshCaptcha({
+          captchaRefreshUrl: `${this.requiredCaptcha.refreshURL}&siteFullName=${hostname}`,
+          captchaId: this.requiredCaptcha.captchaId,
+        })
+        .then((response) => {
+          this.requiredCaptcha.captchaId = response.body.captchaID;
+          this.requiredCaptcha.verificationImageURL = response.body.verificationImageURL;
+          this.requiredCaptcha.verificationAudioURL = response.body.verificationAudioURL;
+        })
+        .catch((error) => {
+          LoggerProxy.logger.error(
+            `Meeting:index#refreshCaptcha --> Error Unable to refresh captcha for ${this.destination} - ${error}`
+          );
+          throw error;
+        })
+    );
+  }
+
+  /**
+   * Posts metrics event for this meeting. Allows the app to send Call Analyzer events.
+   * @param {String} eventName - Call Analyzer event, see eventType in src/metrics/config.ts for possible values
+   * @public
+   * @memberof Meeting
+   * @returns {Promise}
+   */
+  public postMetrics(eventName: string) {
+    Metrics.postEvent({
+      event: eventName,
+      meeting: this,
+    });
   }
 
   /**
@@ -1229,6 +1465,7 @@ export default class Meeting extends StatelessWebexPlugin {
     // meeting update listeners
     this.setUpLocusInfoSelfListener();
     this.setUpLocusInfoMeetingListener();
+    this.setUpLocusServicesListener();
     // members update listeners
     this.setUpLocusFullStateListener();
     this.setUpLocusUrlListener();
@@ -1241,6 +1478,116 @@ export default class Meeting extends StatelessWebexPlugin {
     this.setUpLocusInfoMeetingInfoListener();
     this.setUpLocusInfoAssignHostListener();
     this.setUpLocusInfoMediaInactiveListener();
+    this.setUpBreakoutsListener();
+    this.setUpInterpretationListener();
+  }
+
+  /**
+   * Set up the listeners for breakouts
+   * @returns {undefined}
+   * @private
+   * @memberof Meeting
+   */
+  setUpBreakoutsListener() {
+    this.breakouts.on(BREAKOUTS.EVENTS.BREAKOUTS_CLOSING, () => {
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpBreakoutsListener',
+        },
+        EVENT_TRIGGERS.MEETING_BREAKOUTS_CLOSING
+      );
+    });
+
+    this.breakouts.on(BREAKOUTS.EVENTS.MESSAGE, (messageEvent) => {
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpBreakoutsListener',
+        },
+        EVENT_TRIGGERS.MEETING_BREAKOUTS_MESSAGE,
+        messageEvent
+      );
+    });
+
+    this.breakouts.on(BREAKOUTS.EVENTS.MEMBERS_UPDATE, () => {
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpBreakoutsListener',
+        },
+        EVENT_TRIGGERS.MEETING_BREAKOUTS_UPDATE
+      );
+    });
+
+    this.breakouts.on(BREAKOUTS.EVENTS.ASK_RETURN_TO_MAIN, () => {
+      if (this.isJoined()) {
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'setUpBreakoutsListener',
+          },
+          EVENT_TRIGGERS.MEETING_BREAKOUTS_ASK_RETURN_TO_MAIN
+        );
+      }
+    });
+
+    this.breakouts.on(BREAKOUTS.EVENTS.LEAVE_BREAKOUT, () => {
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpBreakoutsListener',
+        },
+        EVENT_TRIGGERS.MEETING_BREAKOUTS_LEAVE
+      );
+    });
+
+    this.breakouts.on(BREAKOUTS.EVENTS.ASK_FOR_HELP, (helpEvent) => {
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpBreakoutsListener',
+        },
+        EVENT_TRIGGERS.MEETING_BREAKOUTS_ASK_FOR_HELP,
+        helpEvent
+      );
+    });
+
+    this.breakouts.on(BREAKOUTS.EVENTS.PRE_ASSIGNMENTS_UPDATE, () => {
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpBreakoutsListener',
+        },
+        EVENT_TRIGGERS.MEETING_BREAKOUTS_PRE_ASSIGNMENTS_UPDATE
+      );
+    });
+  }
+
+  /**
+   * Set up the listeners for interpretation
+   * @returns {undefined}
+   * @private
+   * @memberof Meeting
+   */
+  private setUpInterpretationListener() {
+    this.simultaneousInterpretation.on(INTERPRETATION.EVENTS.SUPPORT_LANGUAGES_UPDATE, () => {
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpInterpretationListener',
+        },
+        EVENT_TRIGGERS.MEETING_INTERPRETATION_SUPPORT_LANGUAGES_UPDATE
+      );
+    });
   }
 
   /**
@@ -1356,19 +1703,20 @@ export default class Meeting extends StatelessWebexPlugin {
    * @returns {Object}
    * @memberof Meeting
    */
-  getAnalyzerMetricsPrePayload(
-    options:
-      | {
-          event: string;
-          trackingId: string;
-          locus: object;
-          mediaConnections: Array<any>;
-          errors: object;
-        }
-      | any
-  ) {
+  getAnalyzerMetricsPrePayload(options: {
+    type?: string;
+    event: string;
+    trackingId: string;
+    locus: object;
+    mediaConnections?: Array<any>;
+    errors?: object;
+    meetingLookupUrl?: string;
+    clientType?: any;
+    subClientType?: any;
+    [key: string]: any;
+  }) {
     if (options) {
-      const {event, trackingId, mediaConnections} = options;
+      const {event, trackingId, mediaConnections, meetingLookupUrl} = options;
 
       if (!event) {
         LoggerProxy.logger.error(
@@ -1407,6 +1755,10 @@ export default class Meeting extends StatelessWebexPlugin {
         identifiers.mediaAgentCluster = this.mediaConnections?.[0].mediaAgentCluster;
       }
 
+      if (meetingLookupUrl) {
+        identifiers.meetingLookupUrl = meetingLookupUrl;
+      }
+
       if (options.trackingId) {
         identifiers.trackingId = trackingId;
       }
@@ -1456,12 +1808,12 @@ export default class Meeting extends StatelessWebexPlugin {
         };
       }
 
-      const callInitiateJoinReq = this.getCallInitiateJoinReq();
+      const callInitJoinReq = this.getCallInitJoinReq();
 
-      if (callInitiateJoinReq) {
+      if (callInitJoinReq) {
         options.joinTimes = {
           ...options.joinTimes,
-          callInitiateJoinReq,
+          callInitJoinReq,
         };
       }
 
@@ -1474,15 +1826,31 @@ export default class Meeting extends StatelessWebexPlugin {
         };
       }
 
-      const getTotalJmt = this.getTotalJmt();
+      const totalJmt = this.getTotalJmt();
 
-      if (getTotalJmt) {
+      if (totalJmt) {
         options.joinTimes = {
           ...options.joinTimes,
-          getTotalJmt,
+          totalJmt,
         };
       }
 
+      const curUserType = this.getCurUserType();
+
+      if (curUserType) {
+        options.userType = curUserType;
+      }
+
+      const curLoginType = this.getCurLoginType();
+
+      if (curLoginType) {
+        options.loginType = curLoginType;
+      }
+
+      if (this.environment) {
+        options.environment = this.environment;
+      }
+
       if (options.type === MQA_STATS.CA_TYPE) {
         payload = Metrics.initMediaPayload(options.event, identifiers, options);
       } else {
@@ -1596,11 +1964,7 @@ export default class Meeting extends StatelessWebexPlugin {
       this.pstnUpdate(payload);
 
       // If user moved to a JOINED state and there is a pending floor grant trigger it
-      if (this.floorGrantPending && payload.newSelf.state === MEETING_STATE.STATES.JOINED) {
-        this.requestScreenShareFloor().then(() => {
-          this.floorGrantPending = false;
-        });
-      }
+      this.requestScreenShareFloorIfPending();
     });
   }
 
@@ -1786,6 +2150,43 @@ export default class Meeting extends StatelessWebexPlugin {
       }
     );
 
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_MEETING_BREAKOUT_UPDATED, ({breakout}) => {
+      this.breakouts.updateBreakout(breakout);
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setupLocusControlsListener',
+        },
+        EVENT_TRIGGERS.MEETING_BREAKOUTS_UPDATE
+      );
+    });
+
+    this.locusInfo.on(
+      LOCUSINFO.EVENTS.CONTROLS_MEETING_INTERPRETATION_UPDATED,
+      ({interpretation}) => {
+        this.simultaneousInterpretation.updateInterpretation(interpretation);
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'setupLocusControlsListener',
+          },
+          EVENT_TRIGGERS.MEETING_INTERPRETATION_UPDATE
+        );
+      }
+    );
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_JOIN_BREAKOUT_FROM_MAIN, ({mainLocusUrl}) => {
+      this.meetingRequest.getLocusStatusByUrl(mainLocusUrl).catch((error) => {
+        // clear main session cache when attendee join into breakout and forbidden to get locus from main locus url,
+        // which means main session is not active for the attendee
+        if (error?.statusCode === 403) {
+          this.locusInfo.clearMainSessionLocusCache();
+        }
+      });
+    });
+
     this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_ENTRY_EXIT_TONE_UPDATED, ({entryExitTone}) => {
       Trigger.trigger(
         this,
@@ -1797,6 +2198,96 @@ export default class Meeting extends StatelessWebexPlugin {
         {entryExitTone}
       );
     });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_MUTE_ON_ENTRY_CHANGED, ({state}) => {
+      Trigger.trigger(
+        this,
+        {file: 'meeting/index', function: 'setupLocusControlsListener'},
+        EVENT_TRIGGERS.MEETING_CONTROLS_MUTE_ON_ENTRY_UPDATED,
+        {state}
+      );
+    });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_SHARE_CONTROL_CHANGED, ({state}) => {
+      Trigger.trigger(
+        this,
+        {file: 'meeting/index', function: 'setupLocusControlsListener'},
+        EVENT_TRIGGERS.MEETING_CONTROLS_SHARE_CONTROL_UPDATED,
+        {state}
+      );
+    });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_DISALLOW_UNMUTE_CHANGED, ({state}) => {
+      Trigger.trigger(
+        this,
+        {file: 'meeting/index', function: 'setupLocusControlsListener'},
+        EVENT_TRIGGERS.MEETING_CONTROLS_DISALLOW_UNMUTE_UPDATED,
+        {state}
+      );
+    });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_REACTIONS_CHANGED, ({state}) => {
+      Trigger.trigger(
+        this,
+        {file: 'meeting/index', function: 'setupLocusControlsListener'},
+        EVENT_TRIGGERS.MEETING_CONTROLS_REACTIONS_UPDATED,
+        {state}
+      );
+    });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_VIEW_THE_PARTICIPANTS_LIST_CHANGED, ({state}) => {
+      Trigger.trigger(
+        this,
+        {file: 'meeting/index', function: 'setupLocusControlsListener'},
+        EVENT_TRIGGERS.MEETING_CONTROLS_VIEW_THE_PARTICIPANTS_LIST_UPDATED,
+        {state}
+      );
+    });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_RAISE_HAND_CHANGED, ({state}) => {
+      Trigger.trigger(
+        this,
+        {file: 'meeting/index', function: 'setupLocusControlsListener'},
+        EVENT_TRIGGERS.MEETING_CONTROLS_RAISE_HAND_UPDATED,
+        {state}
+      );
+    });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_VIDEO_CHANGED, ({state}) => {
+      Trigger.trigger(
+        this,
+        {file: 'meeting/index', function: 'setupLocusControlsListener'},
+        EVENT_TRIGGERS.MEETING_CONTROLS_VIDEO_UPDATED,
+        {state}
+      );
+    });
+  }
+
+  /**
+   * Trigger annotation info update event
+   @returns {undefined}
+   @param {object} contentShare
+   @param {object} previousContentShare
+   */
+  private triggerAnnotationInfoEvent(contentShare, previousContentShare) {
+    if (
+      contentShare?.annotation &&
+      !isEqual(contentShare?.annotation, previousContentShare?.annotation)
+    ) {
+      Trigger.trigger(
+        // @ts-ignore
+        this.webex.meetings,
+        {
+          file: 'meeting/index',
+          function: 'triggerAnnotationInfoEvent',
+        },
+        EVENT_TRIGGERS.MEETING_UPDATE_ANNOTATION_INFO,
+        {
+          annotationInfo: contentShare?.annotation,
+          meetingId: this.id,
+        }
+      );
+    }
   }
 
   /**
@@ -1809,11 +2300,13 @@ export default class Meeting extends StatelessWebexPlugin {
    */
   private setUpLocusMediaSharesListener() {
     // Will get triggered on local and remote share
-    this.locusInfo.on(EVENTS.LOCUS_INFO_UPDATE_MEDIA_SHARES, (payload) => {
+    this.locusInfo.on(EVENTS.LOCUS_INFO_UPDATE_MEDIA_SHARES, async (payload) => {
       const {content: contentShare, whiteboard: whiteboardShare} = payload.current;
       const previousContentShare = payload.previous?.content;
       const previousWhiteboardShare = payload.previous?.whiteboard;
 
+      this.triggerAnnotationInfoEvent(contentShare, previousContentShare);
+
       if (
         contentShare.beneficiaryId === previousContentShare?.beneficiaryId &&
         contentShare.disposition === previousContentShare?.disposition &&
@@ -1841,19 +2334,8 @@ export default class Meeting extends StatelessWebexPlugin {
         this.selfId === contentShare.beneficiaryId &&
         contentShare.disposition === FLOOR_ACTION.GRANTED
       ) {
-        if (this.mediaProperties.shareTrack?.readyState === 'ended') {
-          this.stopShare({
-            skipSignalingCheck: true,
-          }).catch((error) => {
-            LoggerProxy.logger.log(
-              'Meeting:index#setUpLocusMediaSharesListener --> Error stopping share: ',
-              error
-            );
-          });
-        } else {
-          // CONTENT - sharing content local
-          newShareStatus = SHARE_STATUS.LOCAL_SHARE_ACTIVE;
-        }
+        // CONTENT - sharing content local
+        newShareStatus = SHARE_STATUS.LOCAL_SHARE_ACTIVE;
       }
       // If we did not hit the cases above, no one is sharng content, so we check if we are sharing whiteboard
       // There is no concept of local/remote share for whiteboard
@@ -1937,23 +2419,22 @@ export default class Meeting extends StatelessWebexPlugin {
                 EVENT_TRIGGERS.MEETING_STARTED_SHARING_REMOTE,
                 {
                   memberId: contentShare.beneficiaryId,
+                  url: contentShare.url,
+                  shareInstanceId: contentShare.shareInstanceId,
                 }
               );
             };
 
-            // if a remote participant is stealing the presentation from us
-            if (
-              !this.mediaProperties.mediaDirection?.sendShare ||
-              oldShareStatus === SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE
-            ) {
+            try {
+              // if a remote participant is stealing the presentation from us
+              if (
+                this.mediaProperties.mediaDirection?.sendShare &&
+                oldShareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE
+              ) {
+                await this.unpublishTracks([this.mediaProperties.shareTrack]); // todo screen share audio (SPARK-399690)
+              }
+            } finally {
               sendStartedSharingRemote();
-            } else {
-              this.updateShare({
-                sendShare: false,
-                receiveShare: this.mediaProperties.mediaDirection.receiveShare,
-              }).finally(() => {
-                sendStartedSharingRemote();
-              });
             }
             break;
           }
@@ -2007,6 +2488,8 @@ export default class Meeting extends StatelessWebexPlugin {
           EVENT_TRIGGERS.MEETING_STARTED_SHARING_REMOTE,
           {
             memberId: contentShare.beneficiaryId,
+            url: contentShare.url,
+            shareInstanceId: contentShare.shareInstanceId,
           }
         );
         this.members.locusMediaSharesUpdate(payload);
@@ -2041,8 +2524,31 @@ export default class Meeting extends StatelessWebexPlugin {
   private setUpLocusUrlListener() {
     this.locusInfo.on(EVENTS.LOCUS_INFO_UPDATE_URL, (payload) => {
       this.members.locusUrlUpdate(payload);
+      this.breakouts.locusUrlUpdate(payload);
+      this.simultaneousInterpretation.locusUrlUpdate(payload);
+      this.annotation.locusUrlUpdate(payload);
       this.locusUrl = payload;
       this.locusId = this.locusUrl?.split('/').pop();
+      this.recordingController.setLocusUrl(this.locusUrl);
+      this.controlsOptionsManager.setLocusUrl(this.locusUrl);
+    });
+  }
+
+  /**
+   * Set up the locus info service link listener
+   * update the locusInfo for recording controller
+   * does not currently re-emit the event as it's internal only
+   * payload is unused
+   * @returns {undefined}
+   * @private
+   * @memberof Meeting
+   */
+  private setUpLocusServicesListener() {
+    this.locusInfo.on(LOCUSINFO.EVENTS.LINKS_SERVICES, (payload) => {
+      this.recordingController.setServiceUrl(payload?.services?.record?.url);
+      this.recordingController.setSessionId(this.locusInfo?.fullState?.sessionId);
+      this.breakouts.breakoutServiceUrlUpdate(payload?.services?.breakout?.url);
+      this.annotation.approvalUrlUpdate(payload?.services?.approval?.url);
     });
   }
 
@@ -2092,10 +2598,22 @@ export default class Meeting extends StatelessWebexPlugin {
           canAdmitParticipant: MeetingUtil.canAdmitParticipant(payload.info.userDisplayHints),
           canLock: MeetingUtil.canUserLock(payload.info.userDisplayHints),
           canUnlock: MeetingUtil.canUserUnlock(payload.info.userDisplayHints),
-          canStartRecording: MeetingUtil.canUserRecord(payload.info.userDisplayHints),
-          canStopRecording: MeetingUtil.canUserStop(payload.info.userDisplayHints),
-          canPauseRecording: MeetingUtil.canUserPause(payload.info.userDisplayHints),
-          canResumeRecording: MeetingUtil.canUserResume(payload.info.userDisplayHints),
+          canSetDisallowUnmute: ControlsOptionsUtil.canSetDisallowUnmute(
+            payload.info.userDisplayHints
+          ),
+          canUnsetDisallowUnmute: ControlsOptionsUtil.canUnsetDisallowUnmute(
+            payload.info.userDisplayHints
+          ),
+          canSetMuteOnEntry: ControlsOptionsUtil.canSetMuteOnEntry(payload.info.userDisplayHints),
+          canUnsetMuteOnEntry: ControlsOptionsUtil.canUnsetMuteOnEntry(
+            payload.info.userDisplayHints
+          ),
+          canSetMuted: ControlsOptionsUtil.canSetMuted(payload.info.userDisplayHints),
+          canUnsetMuted: ControlsOptionsUtil.canUnsetMuted(payload.info.userDisplayHints),
+          canStartRecording: RecordingUtil.canUserStart(payload.info.userDisplayHints),
+          canStopRecording: RecordingUtil.canUserStop(payload.info.userDisplayHints),
+          canPauseRecording: RecordingUtil.canUserPause(payload.info.userDisplayHints),
+          canResumeRecording: RecordingUtil.canUserResume(payload.info.userDisplayHints),
           canRaiseHand: MeetingUtil.canUserRaiseHand(payload.info.userDisplayHints),
           canLowerAllHands: MeetingUtil.canUserLowerAllHands(payload.info.userDisplayHints),
           canLowerSomeoneElsesHand: MeetingUtil.canUserLowerSomeoneElsesHand(
@@ -2108,6 +2626,9 @@ export default class Meeting extends StatelessWebexPlugin {
           canStartTranscribing: MeetingUtil.canStartTranscribing(payload.info.userDisplayHints),
           canStopTranscribing: MeetingUtil.canStopTranscribing(payload.info.userDisplayHints),
           isClosedCaptionActive: MeetingUtil.isClosedCaptionActive(payload.info.userDisplayHints),
+          isSaveTranscriptsEnabled: MeetingUtil.isSaveTranscriptsEnabled(
+            payload.info.userDisplayHints
+          ),
           isWebexAssistantActive: MeetingUtil.isWebexAssistantActive(payload.info.userDisplayHints),
           canViewCaptionPanel: MeetingUtil.canViewCaptionPanel(payload.info.userDisplayHints),
           isRealTimeTranslationEnabled: MeetingUtil.isRealTimeTranslationEnabled(
@@ -2117,8 +2638,118 @@ export default class Meeting extends StatelessWebexPlugin {
             payload.info.userDisplayHints
           ),
           waitingForOthersToJoin: MeetingUtil.waitingForOthersToJoin(payload.info.userDisplayHints),
+          canSendReactions: MeetingUtil.canSendReactions(
+            this.inMeetingActions.canSendReactions,
+            payload.info.userDisplayHints
+          ),
+          canManageBreakout: MeetingUtil.canManageBreakout(payload.info.userDisplayHints),
+          canBroadcastMessageToBreakout: MeetingUtil.canBroadcastMessageToBreakout(
+            payload.info.userDisplayHints
+          ),
+          canAdmitLobbyToBreakout: MeetingUtil.canAdmitLobbyToBreakout(
+            payload.info.userDisplayHints
+          ),
+          isBreakoutPreassignmentsEnabled: MeetingUtil.isBreakoutPreassignmentsEnabled(
+            payload.info.userDisplayHints
+          ),
+          canUserAskForHelp: MeetingUtil.canUserAskForHelp(payload.info.userDisplayHints),
+          canUserRenameSelfAndObserved: MeetingUtil.canUserRenameSelfAndObserved(
+            payload.info.userDisplayHints
+          ),
+          canUserRenameOthers: MeetingUtil.canUserRenameOthers(payload.info.userDisplayHints),
+          canMuteAll: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.MUTE_ALL],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canUnmuteAll: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.UNMUTE_ALL],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canEnableHardMute: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_HARD_MUTE],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canDisableHardMute: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_HARD_MUTE],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canEnableMuteOnEntry: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_MUTE_ON_ENTRY],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canDisableMuteOnEntry: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_MUTE_ON_ENTRY],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canEnableReactions: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_REACTIONS],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canDisableReactions: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_REACTIONS],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canEnableReactionDisplayNames: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_SHOW_DISPLAY_NAME],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canDisableReactionDisplayNames: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_SHOW_DISPLAY_NAME],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canUpdateShareControl: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.SHARE_CONTROL],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canEnableViewTheParticipantsList: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canDisableViewTheParticipantsList: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_VIEW_THE_PARTICIPANT_LIST],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canEnableRaiseHand: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_RAISE_HAND],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canDisableRaiseHand: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_RAISE_HAND],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canEnableVideo: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.ENABLE_VIDEO],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canDisableVideo: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.DISABLE_VIDEO],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canShareFile: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.SHARE_FILE],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canShareApplication: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.SHARE_APPLICATION],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canShareCamera: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.SHARE_CAMERA],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canShareDesktop: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.SHARE_DESKTOP],
+            displayHints: payload.info.userDisplayHints,
+          }),
+          canShareContent: ControlsOptionsUtil.hasHints({
+            requiredHints: [DISPLAY_HINTS.SHARE_CONTENT],
+            displayHints: payload.info.userDisplayHints,
+          }),
         });
 
+        this.recordingController.setDisplayHints(payload.info.userDisplayHints);
+        this.controlsOptionsManager.setDisplayHints(payload.info.userDisplayHints);
+
         if (changed) {
           Trigger.trigger(
             this,
@@ -2141,7 +2772,9 @@ export default class Meeting extends StatelessWebexPlugin {
    * @param {String} datachannelUrl
    * @returns {void}
    */
+
   handleDataChannelUrlChange(datachannelUrl) {
+    // @ts-ignore - config coming from registerPlugin
     if (datachannelUrl && this.config.enableAutomaticLLM) {
       // Defer this as updateLLMConnection relies upon this.locusInfo.url which is only set
       // after the MEETING_INFO_UPDATED callback finishes
@@ -2196,10 +2829,34 @@ export default class Meeting extends StatelessWebexPlugin {
         );
       }
     });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED, (payload) => {
+      if (payload) {
+        if (this.video) {
+          payload.muted = payload.muted ?? this.video.isRemotelyMuted();
+          payload.unmuteAllowed = payload.unmuteAllowed ?? this.video.isUnmuteAllowed();
+          this.video.handleServerRemoteMuteUpdate(this, payload.muted, payload.unmuteAllowed);
+        }
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'setUpLocusInfoSelfListener',
+          },
+          payload.muted
+            ? EVENT_TRIGGERS.MEETING_SELF_VIDEO_MUTED_BY_OTHERS
+            : EVENT_TRIGGERS.MEETING_SELF_VIDEO_UNMUTED_BY_OTHERS,
+          {
+            payload,
+          }
+        );
+      }
+    });
+
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_REMOTE_MUTE_STATUS_UPDATED, (payload) => {
       if (payload) {
         if (this.audio) {
-          this.audio.handleServerRemoteMuteUpdate(payload.muted, payload.unmuteAllowed);
+          this.audio.handleServerRemoteMuteUpdate(this, payload.muted, payload.unmuteAllowed);
         }
         // with "mute on entry" server will send us remote mute even if we don't have media configured,
         // so if being muted by others, always send the notification,
@@ -2322,6 +2979,51 @@ export default class Meeting extends StatelessWebexPlugin {
       );
     });
 
+    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_MEETING_BREAKOUTS_CHANGED, (payload) => {
+      this.breakouts.updateBreakoutSessions(payload);
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpLocusInfoSelfListener',
+        },
+        EVENT_TRIGGERS.MEETING_BREAKOUTS_UPDATE
+      );
+    });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_MEETING_INTERPRETATION_CHANGED, (payload) => {
+      this.simultaneousInterpretation.updateSelfInterpretation(payload);
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpLocusInfoSelfListener',
+        },
+        EVENT_TRIGGERS.MEETING_INTERPRETATION_UPDATE
+      );
+    });
+
+    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_ROLES_CHANGED, (payload) => {
+      const isModeratorOrCohost =
+        payload.newRoles?.includes(SELF_ROLES.MODERATOR) ||
+        payload.newRoles?.includes(SELF_ROLES.COHOST);
+      this.breakouts.updateCanManageBreakouts(isModeratorOrCohost);
+      this.simultaneousInterpretation.updateCanManageInterpreters(
+        payload.newRoles?.includes(SELF_ROLES.MODERATOR)
+      );
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpLocusInfoSelfListener',
+        },
+        EVENT_TRIGGERS.MEETING_SELF_ROLES_CHANGED,
+        {
+          payload,
+        }
+      );
+    });
+
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_IS_SHARING_BLOCKED_CHANGE, (payload) => {
       Trigger.trigger(
         this,
@@ -2357,19 +3059,18 @@ export default class Meeting extends StatelessWebexPlugin {
           .catch((error) => {
             // @ts-ignore
             LoggerProxy.logger.error(
-              `Meeting:index#setUpLocusInfoMeetingListener --> REMOTE_RESPONSE. Issue with leave for meeting, meeting still in collection: ${this.meeting}, error: ${error}`
+              `Meeting:index#setUpLocusInfoMeetingListener --> REMOTE_RESPONSE. Issue with leave for meeting, meeting still in collection: ${this}, error: ${error}`
             );
           });
       }
     });
-    this.locusInfo.on(EVENTS.DESTROY_MEETING, (payload) => {
+    this.locusInfo.on(EVENTS.DESTROY_MEETING, async (payload) => {
       // if self state is NOT left
 
       // TODO: Handle sharing and wireless sharing when meeting end
       if (this.wirelessShare) {
         if (this.mediaProperties.shareTrack) {
-          this.mediaProperties.shareTrack.onended = null;
-          this.mediaProperties.shareTrack.stop();
+          await this.setLocalShareTrack(undefined);
         }
       }
       // when multiple WEB deviceType join with same user
@@ -2383,18 +3084,18 @@ export default class Meeting extends StatelessWebexPlugin {
       if (payload.shouldLeave) {
         // TODO:  We should do cleaning of meeting object if the shouldLeave: false because there might be meeting object which we are not cleaning
 
-        this.leave({reason: payload.reason})
-          .then(() => {
-            LoggerProxy.logger.warn(
-              'Meeting:index#setUpLocusInfoMeetingListener --> DESTROY_MEETING. The meeting has been left, but has not been destroyed, you should see a later event for leave.'
-            );
-          })
-          .catch((error) => {
-            // @ts-ignore
-            LoggerProxy.logger.error(
-              `Meeting:index#setUpLocusInfoMeetingListener --> DESTROY_MEETING. Issue with leave for meeting, meeting still in collection: ${this.meeting}, error: ${error}`
-            );
-          });
+        try {
+          await this.leave({reason: payload.reason});
+
+          LoggerProxy.logger.warn(
+            'Meeting:index#setUpLocusInfoMeetingListener --> DESTROY_MEETING. The meeting has been left, but has not been destroyed, you should see a later event for leave.'
+          );
+        } catch (error) {
+          // @ts-ignore
+          LoggerProxy.logger.error(
+            `Meeting:index#setUpLocusInfoMeetingListener --> DESTROY_MEETING. Issue with leave for meeting, meeting still in collection: ${this}, error: ${error}`
+          );
+        }
       } else {
         LoggerProxy.logger.info(
           'Meeting:index#setUpLocusInfoMeetingListener --> MEETING_REMOVED_REASON',
@@ -2472,14 +3173,32 @@ export default class Meeting extends StatelessWebexPlugin {
   }
 
   /**
-   * Admit the guest(s) to the call once they are waiting
+   * Admit the guest(s) to the call once they are waiting.
+   * If the host/cohost is in a breakout session, the locus url
+   * of the session must be provided as the authorizingLocusUrl.
+   * Regardless of host/cohost location, the locus Id (lid) in
+   * the path should be the locus Id of the main, which means the
+   * locus url of the api call must be from the main session.
+   * If these loucs urls are not provided, the function will do the check.
    * @param {Array} memberIds
+   * @param {Object} sessionLocusUrls: {authorizingLocusUrl, mainLocusUrl}
    * @returns {Promise} see #members.admitMembers
    * @public
    * @memberof Meeting
    */
-  public admit(memberIds: Array<any>) {
-    return this.members.admitMembers(memberIds);
+  public admit(
+    memberIds: Array<any>,
+    sessionLocusUrls?: {authorizingLocusUrl: string; mainLocusUrl: string}
+  ) {
+    let locusUrls = sessionLocusUrls;
+    if (!locusUrls) {
+      const {locusUrl, mainLocusUrl} = this.breakouts;
+      if (locusUrl && mainLocusUrl) {
+        locusUrls = {authorizingLocusUrl: locusUrl, mainLocusUrl};
+      }
+    }
+
+    return this.members.admitMembers(memberIds, locusUrls);
   }
 
   /**
@@ -2527,66 +3246,6 @@ export default class Meeting extends StatelessWebexPlugin {
     return this.members;
   }
 
-  /**
-   * Truthy when a meeting has an audio connection established
-   * @returns {Boolean}  true if meeting audio is connected otherwise false
-   * @public
-   * @memberof Meeting
-   */
-  public isAudioConnected() {
-    return !!this.audio;
-  }
-
-  /**
-   * Convenience function to tell whether a meeting is muted
-   * @returns {Boolean} if meeting audio muted or not
-   * @public
-   * @memberof Meeting
-   */
-  public isAudioMuted() {
-    return this.audio && this.audio.isMuted();
-  }
-
-  /**
-   * Convenience function to tell if the end user last changed the audio state
-   * @returns {Boolean} if audio was manipulated by the end user
-   * @public
-   * @memberof Meeting
-   */
-  public isAudioSelf() {
-    return this.audio && this.audio.isSelf();
-  }
-
-  /**
-   * Truthy when a meeting has a video connection established
-   * @returns {Boolean} true if meeting video connected otherwise false
-   * @public
-   * @memberof Meeting
-   */
-  public isVideoConnected() {
-    return !!this.video;
-  }
-
-  /**
-   * Convenience function to tell whether video is muted
-   * @returns {Boolean} if meeting video is muted or not
-   * @public
-   * @memberof Meeting
-   */
-  public isVideoMuted() {
-    return this.video && this.video.isMuted();
-  }
-
-  /**
-   * Convenience function to tell whether the end user changed the video state
-   * @returns {Boolean} if meeting video is muted or not
-   * @public
-   * @memberof Meeting
-   */
-  public isVideoSelf() {
-    return this.video && this.video.isSelf();
-  }
-
   /**
    * Sets the meeting info on the class instance
    * @param {Object} meetingInfo
@@ -2634,6 +3293,7 @@ export default class Meeting extends StatelessWebexPlugin {
       this.locusUrl = locusMeetingObject?.url || webexMeetingInfo?.locusUrl || this.locusUrl;
       // @ts-ignore - config coming from registerPlugin
       this.setSipUri(
+        // @ts-ignore
         this.config.experimental.enableUnifiedMeetings
           ? locusMeetingObject?.info.sipUri || webexMeetingInfo?.sipUrl
           : locusMeetingObject?.info.sipUri || webexMeetingInfo?.sipMeetingUri || this.sipUri
@@ -2650,35 +3310,8 @@ export default class Meeting extends StatelessWebexPlugin {
         webexMeetingInfo?.hostId ||
         this.owner;
       this.permissionToken = webexMeetingInfo?.permissionToken;
-    }
-  }
-
-  /**
-   * Sets the first locus info on the class instance
-   * @param {Object} locus
-   * @param {String} locus.url
-   * @param {Array} locus.participants
-   * @param {Object} locus.self
-   * @returns {undefined}
-   * @private
-   * @memberof Meeting
-   */
-  private parseLocus(locus: {url: string; participants: Array<any>; self: object}) {
-    if (locus) {
-      this.locusUrl = locus.url;
-      // TODO: move this to parse participants module
-      this.setLocus(locus);
-
-      // check if we can extract this info from partner
-      // Parsing of locus object must be finished at this state
-      if (locus.participants && locus.self) {
-        this.partner = MeetingUtil.getLocusPartner(locus.participants, locus.self);
-      }
-
-      // For webex meeting the sipUrl gets updated in info parser
-      if (!this.sipUri && this.partner && this.type === _CALL_) {
-        this.setSipUri(this.partner.person.sipUrl || this.partner.person.id);
-      }
+      // Need to populate environment when sending CA event
+      this.environment = locusMeetingObject?.info.channel || webexMeetingInfo?.channel;
     }
   }
 
@@ -2708,7 +3341,7 @@ export default class Meeting extends StatelessWebexPlugin {
    * @private
    * @memberof Meeting
    */
-  private setLocus(
+  setLocus(
     locus:
       | {
           mediaConnections: Array<any>;
@@ -2743,21 +3376,6 @@ export default class Meeting extends StatelessWebexPlugin {
     Trigger.trigger(this, options, EVENTS.REQUEST_UPLOAD_LOGS, this);
   }
 
-  /**
-   * Removes remote audio and video stream on the class instance and triggers an event
-   * to developers
-   * @returns {undefined}
-   * @public
-   * @memberof Meeting
-   * @deprecated after v1.89.3
-   */
-  public unsetRemoteStream() {
-    LoggerProxy.logger.warn(
-      'Meeting:index#unsetRemoteStream --> [DEPRECATION WARNING]: unsetRemoteStream has been deprecated after v1.89.3'
-    );
-    this.mediaProperties.unsetRemoteMedia();
-  }
-
   /**
    * Removes remote audio, video and share tracks from class instance's mediaProperties
    * @returns {undefined}
@@ -2842,257 +3460,124 @@ export default class Meeting extends StatelessWebexPlugin {
   }
 
   /**
-   * Emits the 'media:ready' event with a local stream that consists of 1 local audio and 1 local video track
-   * @returns {undefined}
-   * @private
-   * @memberof Meeting
+   * Stores the reference to a new microphone track, sets up the required event listeners
+   * on it, cleans up previous track, etc.
+   *
+   * @param {LocalMicrophoneTrack | null} localTrack local microphone track
+   * @returns {Promise<void>}
    */
-  private sendLocalMediaReadyEvent() {
-    Trigger.trigger(
-      this,
-      {
-        file: 'meeting/index',
-        function: 'setLocalTracks',
-      },
-      EVENT_TRIGGERS.MEDIA_READY,
-      {
-        type: EVENT_TYPES.LOCAL,
-        stream: MediaUtil.createMediaStream([
-          this.mediaProperties.audioTrack,
-          this.mediaProperties.videoTrack,
-        ]),
-      }
-    );
-  }
+  private async setLocalAudioTrack(localTrack?: LocalMicrophoneTrack) {
+    const oldTrack = this.mediaProperties.audioTrack;
 
-  /**
-   * Sets the local audio track on the class and emits an event to the developer
-   * @param {MediaStreamTrack} audioTrack
-   * @param {Boolean} emitEvent if true, a media ready event is emitted to the developer
-   * @returns {undefined}
-   * @private
-   * @memberof Meeting
-   */
-  private setLocalAudioTrack(audioTrack: MediaStreamTrack, emitEvent = true) {
-    if (audioTrack) {
-      const settings = audioTrack.getSettings();
+    oldTrack?.off(LocalTrackEvents.Muted, this.localAudioTrackMuteStateHandler);
+    oldTrack?.off(LocalTrackEvents.UnderlyingTrackChange, this.underlyingLocalTrackChangeHandler);
 
-      this.mediaProperties.setMediaSettings('audio', {
-        echoCancellation: settings.echoCancellation,
-        noiseSuppression: settings.noiseSuppression,
-      });
+    // we don't update this.mediaProperties.mediaDirection.sendAudio, because we always keep it as true to avoid extra SDP exchanges
+    this.mediaProperties.setLocalAudioTrack(localTrack);
 
-      LoggerProxy.logger.log(
-        'Meeting:index#setLocalAudioTrack --> Audio settings.',
-        JSON.stringify(this.mediaProperties.mediaSettings.audio)
-      );
-      this.mediaProperties.setLocalAudioTrack(audioTrack);
-      if (this.audio) this.audio.applyClientStateLocally(this);
-    }
+    this.audio.handleLocalTrackChange(this);
 
-    if (emitEvent) {
-      this.sendLocalMediaReadyEvent();
+    localTrack?.on(LocalTrackEvents.Muted, this.localAudioTrackMuteStateHandler);
+    localTrack?.on(LocalTrackEvents.UnderlyingTrackChange, this.underlyingLocalTrackChangeHandler);
+
+    if (!this.isMultistream || !localTrack) {
+      // for multistream WCME automatically un-publishes the old track when we publish a new one
+      await this.unpublishTrack(oldTrack);
     }
+    await this.publishTrack(this.mediaProperties.audioTrack);
   }
 
   /**
-   * Sets the local video track on the class and emits an event to the developer
-   * @param {MediaStreamTrack} videoTrack
-   * @param {Boolean} emitEvent if true, a media ready event is emitted to the developer
-   * @returns {undefined}
-   * @private
-   * @memberof Meeting
+   * Stores the reference to a new camera track, sets up the required event listeners
+   * on it, cleans up previous track, etc.
+   *
+   * @param {LocalCameraTrack | null} localTrack local camera track
+   * @returns {Promise<void>}
    */
-  private setLocalVideoTrack(videoTrack: MediaStreamTrack, emitEvent = true) {
-    if (videoTrack) {
-      const {aspectRatio, frameRate, height, width, deviceId} = videoTrack.getSettings();
-
-      const {localQualityLevel} = this.mediaProperties;
+  private async setLocalVideoTrack(localTrack?: LocalCameraTrack) {
+    const oldTrack = this.mediaProperties.videoTrack;
 
-      if (Number(localQualityLevel.slice(0, -1)) > height) {
-        LoggerProxy.logger
-          .warn(`Meeting:index#setLocalVideoTrack --> Local video quality of ${localQualityLevel} not supported,
-         downscaling to highest possible resolution of ${height}p`);
+    oldTrack?.off(LocalTrackEvents.Muted, this.localVideoTrackMuteStateHandler);
+    oldTrack?.off(LocalTrackEvents.UnderlyingTrackChange, this.underlyingLocalTrackChangeHandler);
 
-        this.mediaProperties.setLocalQualityLevel(`${height}p`);
-      }
+    // we don't update this.mediaProperties.mediaDirection.sendVideo, because we always keep it as true to avoid extra SDP exchanges
+    this.mediaProperties.setLocalVideoTrack(localTrack);
 
-      this.mediaProperties.setLocalVideoTrack(videoTrack);
-      if (this.video) this.video.applyClientStateLocally(this);
+    this.video.handleLocalTrackChange(this);
 
-      this.mediaProperties.setMediaSettings('video', {
-        aspectRatio,
-        frameRate,
-        height,
-        width,
-      });
-      // store and save the selected video input device
-      if (deviceId) {
-        this.mediaProperties.setVideoDeviceId(deviceId);
-      }
-      LoggerProxy.logger.log(
-        'Meeting:index#setLocalVideoTrack --> Video settings.',
-        JSON.stringify(this.mediaProperties.mediaSettings.video)
-      );
-    }
+    localTrack?.on(LocalTrackEvents.Muted, this.localVideoTrackMuteStateHandler);
+    localTrack?.on(LocalTrackEvents.UnderlyingTrackChange, this.underlyingLocalTrackChangeHandler);
 
-    if (emitEvent) {
-      this.sendLocalMediaReadyEvent();
+    if (!this.isMultistream || !localTrack) {
+      // for multistream WCME automatically un-publishes the old track when we publish a new one
+      await this.unpublishTrack(oldTrack);
     }
+    await this.publishTrack(this.mediaProperties.videoTrack);
   }
 
   /**
-   * Sets the local media stream on the class and emits an event to the developer
-   * @param {Stream} localStream the local media stream
-   * @returns {undefined}
-   * @public
-   * @memberof Meeting
+   * Stores the reference to a new screen share track, sets up the required event listeners
+   * on it, cleans up previous track, etc.
+   * It also sends the floor grant/release request.
+   *
+   * @param {LocalDisplayTrack | undefined} localDisplayTrack local camera track
+   * @returns {Promise<void>}
    */
-  public setLocalTracks(localStream: any) {
-    if (localStream) {
-      const {audioTrack, videoTrack} = MeetingUtil.getTrack(localStream);
+  private async setLocalShareTrack(localDisplayTrack?: LocalDisplayTrack) {
+    const oldTrack = this.mediaProperties.shareTrack;
 
-      this.setLocalAudioTrack(audioTrack, false);
-      this.setLocalVideoTrack(videoTrack, false);
+    oldTrack?.off(LocalTrackEvents.Ended, this.handleShareTrackEnded);
+    oldTrack?.off(LocalTrackEvents.UnderlyingTrackChange, this.underlyingLocalTrackChangeHandler);
 
-      this.sendLocalMediaReadyEvent();
-    }
-  }
+    this.mediaProperties.setLocalShareTrack(localDisplayTrack);
 
-  /**
-   * Sets the local media stream on the class and emits an event to the developer
-   * @param {MediaStream} localShare the local media stream
-   * @returns {undefined}
-   * @public
-   * @memberof Meeting
-   */
-  public setLocalShareTrack(localShare: MediaStream) {
-    let settings = null;
-
-    if (localShare) {
-      this.mediaProperties.setLocalShareTrack(MeetingUtil.getTrack(localShare).videoTrack);
-      const contentTracks = this.mediaProperties.shareTrack;
-
-      if (contentTracks) {
-        settings = contentTracks.getSettings();
-        this.mediaProperties.setMediaSettings('screen', {
-          aspectRatio: settings.aspectRatio,
-          frameRate: settings.frameRate,
-          height: settings.height,
-          width: settings.width,
-          displaySurface: settings.displaySurface,
-          cursor: settings.cursor,
-        });
-        LoggerProxy.logger.log(
-          'Meeting:index#setLocalShareTrack --> Screen settings.',
-          JSON.stringify(this.mediaProperties.mediaSettings.screen)
-        );
-      }
+    localDisplayTrack?.on(LocalTrackEvents.Ended, this.handleShareTrackEnded);
+    localDisplayTrack?.on(
+      LocalTrackEvents.UnderlyingTrackChange,
+      this.underlyingLocalTrackChangeHandler
+    );
 
-      contentTracks.onended = () => this.handleShareTrackEnded(localShare);
+    this.mediaProperties.mediaDirection.sendShare = !!localDisplayTrack;
 
-      Trigger.trigger(
-        this,
-        {
-          file: 'meeting/index',
-          function: 'setLocalShareTrack',
-        },
-        EVENT_TRIGGERS.MEDIA_READY,
-        {
-          type: EVENT_TYPES.LOCAL_SHARE,
-          stream: localShare,
-        }
-      );
+    if (!this.isMultistream || !localDisplayTrack) {
+      // for multistream WCME automatically un-publishes the old track when we publish a new one
+      await this.unpublishTrack(oldTrack);
     }
+    await this.publishTrack(this.mediaProperties.shareTrack);
   }
 
   /**
-   * Closes the local stream from the class and emits an event to the developer
-   * @returns {undefined}
-   * @event media:stopped
-   * @public
-   * @memberof Meeting
+   * Removes references to local tracks. This function should be called
+   * on cleanup when we leave the meeting etc.
+   *
+   * @internal
+   * @returns {void}
    */
-  public closeLocalStream() {
-    const {audioTrack, videoTrack} = this.mediaProperties;
+  public cleanupLocalTracks() {
+    const {audioTrack, videoTrack, shareTrack} = this.mediaProperties;
 
-    return Media.stopTracks(audioTrack)
-      .then(() => Media.stopTracks(videoTrack))
-      .then(() => {
-        const audioStopped = audioTrack && audioTrack.readyState === ENDED;
-        const videoStopped = videoTrack && videoTrack.readyState === ENDED;
+    audioTrack?.off(LocalTrackEvents.Muted, this.localAudioTrackMuteStateHandler);
+    audioTrack?.off(LocalTrackEvents.UnderlyingTrackChange, this.underlyingLocalTrackChangeHandler);
 
-        // triggers event for audio and video stop , sometime either audio or video one of them exists
-        if (audioStopped || videoStopped) {
-          Trigger.trigger(
-            this,
-            {
-              file: 'meeting/index',
-              function: 'closeLocalStream',
-            },
-            EVENT_TRIGGERS.MEDIA_STOPPED,
-            {
-              type: EVENT_TYPES.LOCAL,
-            }
-          );
-        } else if (audioTrack || videoTrack) {
-          LoggerProxy.logger.warn(
-            'Meeting:index#closeLocalStream --> Warning: track might already been ended or unavaliable.'
-          );
-        }
-      });
-  }
+    videoTrack?.off(LocalTrackEvents.Muted, this.localVideoTrackMuteStateHandler);
+    videoTrack?.off(LocalTrackEvents.UnderlyingTrackChange, this.underlyingLocalTrackChangeHandler);
 
-  /**
-   * Closes the local stream from the class and emits an event to the developer
-   * @returns {undefined}
-   * @event media:stopped
-   * @public
-   * @memberof Meeting
-   */
-  public closeLocalShare() {
-    const track = this.mediaProperties.shareTrack;
+    shareTrack?.off(LocalTrackEvents.Ended, this.handleShareTrackEnded);
+    shareTrack?.off(LocalTrackEvents.UnderlyingTrackChange, this.underlyingLocalTrackChangeHandler);
 
-    return Media.stopTracks(track).then(() => {
-      if (track && track.readyState === ENDED) {
-        Trigger.trigger(
-          this,
-          {
-            file: 'meeting/index',
-            function: 'closeLocalShare',
-          },
-          EVENT_TRIGGERS.MEDIA_STOPPED,
-          {
-            type: EVENT_TYPES.LOCAL_SHARE,
-          }
-        );
-      } else if (track) {
-        // Track exists but with wrong readyState
-        LoggerProxy.logger.warn(
-          `Meeting:index#closeLocalShare --> Error: MediaStreamTrack.readyState is ${track.readyState} for localShare`
-        );
-      }
-    });
-  }
+    this.mediaProperties.setLocalAudioTrack(undefined);
+    this.mediaProperties.setLocalVideoTrack(undefined);
+    this.mediaProperties.setLocalShareTrack(undefined);
 
-  /**
-   * Removes the local stream from the class and emits an event to the developer
-   * @returns {undefined}
-   * @public
-   * @memberof Meeting
-   */
-  public unsetLocalVideoTrack() {
-    this.mediaProperties.unsetLocalVideoTrack();
-  }
+    this.mediaProperties.mediaDirection.sendAudio = false;
+    this.mediaProperties.mediaDirection.sendVideo = false;
+    this.mediaProperties.mediaDirection.sendShare = false;
 
-  /**
-   * Removes the local share from the class and emits an event to the developer
-   * @returns {undefined}
-   * @public
-   * @memberof Meeting
-   */
-  public unsetLocalShareTrack() {
-    this.mediaProperties.unsetLocalShareTrack();
+    // WCME doesn't unpublish tracks when multistream connection is closed, so we do it here
+    // (we have to do it for transcoded meetings anyway, so we might as well do for multistream too)
+    audioTrack?.setPublished(false);
+    videoTrack?.setPublished(false);
+    shareTrack?.setPublished(false);
   }
 
   /**
@@ -3143,6 +3628,8 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   public closePeerConnections() {
+    this.locusMediaRequest = undefined;
+
     if (this.mediaProperties.webrtcMediaConnection) {
       if (this.remoteMediaManager) {
         this.remoteMediaManager.stop();
@@ -3157,6 +3644,9 @@ export default class Meeting extends StatelessWebexPlugin {
       this.mediaProperties.webrtcMediaConnection.close();
     }
 
+    this.audio = null;
+    this.video = null;
+
     return Promise.resolve();
   }
 
@@ -3187,264 +3677,36 @@ export default class Meeting extends StatelessWebexPlugin {
     this.correlationId = id;
   }
 
-  /**
-   * Mute the audio for a meeting
-   * @returns {Promise} resolves the data from muting audio {mute, self} or rejects if there is no audio set
-   * @public
-   * @memberof Meeting
-   */
-  public muteAudio() {
-    if (!MeetingUtil.isUserInJoinedState(this.locusInfo)) {
-      return Promise.reject(new UserNotJoinedError());
-    }
-
-    // @ts-ignore
-    if (!this.mediaId) {
-      // Happens when addMedia and mute are triggered in succession
-      return Promise.reject(new NoMediaEstablishedYetError());
-    }
-
-    if (!this.audio) {
-      return Promise.reject(new ParameterError('no audio control associated to the meeting'));
-    }
-
-    const LOG_HEADER = 'Meeting:index#muteAudio -->';
-
-    // First, stop sending the local audio media
-    return logRequest(
-      this.audio
-        .handleClientRequest(this, true)
-        .then(() => {
-          MeetingUtil.handleAudioLogging(this.mediaProperties.audioTrack);
-          Metrics.postEvent({
-            event: eventType.MUTED,
-            meeting: this,
-            data: {trigger: trigger.USER_INTERACTION, mediaType: mediaType.AUDIO},
-          });
-        })
-        .catch((error) => {
-          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MUTE_AUDIO_FAILURE, {
-            correlation_id: this.correlationId,
-            locus_id: this.locusUrl.split('/').pop(),
-            reason: error.message,
-            stack: error.stack,
-          });
-
-          throw error;
-        }),
-      {
-        header: `${LOG_HEADER} muting audio`,
-        success: `${LOG_HEADER} muted audio successfully`,
-        failure: `${LOG_HEADER} muting audio failed, `,
-      }
-    );
-  }
-
-  /**
-   * Unmute meeting audio
-   * @returns {Promise} resolves data from muting audio {mute, self} or rejects if there is no audio set
-   * @public
-   * @memberof Meeting
-   */
-  public unmuteAudio() {
-    if (!MeetingUtil.isUserInJoinedState(this.locusInfo)) {
-      return Promise.reject(new UserNotJoinedError());
-    }
-
-    // @ts-ignore
-    if (!this.mediaId) {
-      // Happens when addMedia and mute are triggered in succession
-      return Promise.reject(new NoMediaEstablishedYetError());
-    }
-
-    if (!this.audio) {
-      return Promise.reject(new ParameterError('no audio control associated to the meeting'));
-    }
-
-    const LOG_HEADER = 'Meeting:index#unmuteAudio -->';
-
-    // First, send the control to unmute the participant on the server
-    return logRequest(
-      this.audio
-        .handleClientRequest(this, false)
-        .then(() => {
-          MeetingUtil.handleAudioLogging(this.mediaProperties.audioTrack);
-          Metrics.postEvent({
-            event: eventType.UNMUTED,
-            meeting: this,
-            data: {trigger: trigger.USER_INTERACTION, mediaType: mediaType.AUDIO},
-          });
-        })
-        .catch((error) => {
-          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.UNMUTE_AUDIO_FAILURE, {
-            correlation_id: this.correlationId,
-            locus_id: this.locusUrl.split('/').pop(),
-            reason: error.message,
-            stack: error.stack,
-          });
-
-          throw error;
-        }),
-      {
-        header: `${LOG_HEADER} unmuting audio`,
-        success: `${LOG_HEADER} unmuted audio successfully`,
-        failure: `${LOG_HEADER} unmuting audio failed, `,
-      }
-    );
-  }
-
-  /**
-   * Mute the video for a meeting
-   * @returns {Promise} resolves data from muting video {mute, self} or rejects if there is no video set
-   * @public
-   * @memberof Meeting
-   */
-  public muteVideo() {
-    if (!MeetingUtil.isUserInJoinedState(this.locusInfo)) {
-      return Promise.reject(new UserNotJoinedError());
-    }
-
-    // @ts-ignore
-    if (!this.mediaId) {
-      // Happens when addMedia and mute are triggered in succession
-      return Promise.reject(new NoMediaEstablishedYetError());
-    }
-
-    if (!this.video) {
-      return Promise.reject(new ParameterError('no video control associated to the meeting'));
-    }
-
-    const LOG_HEADER = 'Meeting:index#muteVideo -->';
-
-    return logRequest(
-      this.video
-        .handleClientRequest(this, true)
-        .then(() => {
-          MeetingUtil.handleVideoLogging(this.mediaProperties.videoTrack);
-          Metrics.postEvent({
-            event: eventType.MUTED,
-            meeting: this,
-            data: {trigger: trigger.USER_INTERACTION, mediaType: mediaType.VIDEO},
-          });
-        })
-        .catch((error) => {
-          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MUTE_VIDEO_FAILURE, {
-            correlation_id: this.correlationId,
-            locus_id: this.locusUrl.split('/').pop(),
-            reason: error.message,
-            stack: error.stack,
-          });
-
-          throw error;
-        }),
-      {
-        header: `${LOG_HEADER} muting video`,
-        success: `${LOG_HEADER} muted video successfully`,
-        failure: `${LOG_HEADER} muting video failed, `,
-      }
-    );
-  }
-
-  /**
-   * Unmute meeting video
-   * @returns {Promise} resolves data from muting video {mute, self} or rejects if there is no video set
-   * @public
-   * @memberof Meeting
-   */
-  public unmuteVideo() {
-    if (!MeetingUtil.isUserInJoinedState(this.locusInfo)) {
-      return Promise.reject(new UserNotJoinedError());
-    }
-
-    // @ts-ignore
-    if (!this.mediaId) {
-      // Happens when addMedia and mute are triggered in succession
-      return Promise.reject(new NoMediaEstablishedYetError());
-    }
-
-    if (!this.video) {
-      return Promise.reject(new ParameterError('no audio control associated to the meeting'));
-    }
-
-    const LOG_HEADER = 'Meeting:index#unmuteVideo -->';
-
-    return logRequest(
-      this.video
-        .handleClientRequest(this, false)
-        .then(() => {
-          MeetingUtil.handleVideoLogging(this.mediaProperties.videoTrack);
-          Metrics.postEvent({
-            event: eventType.UNMUTED,
-            meeting: this,
-            data: {trigger: trigger.USER_INTERACTION, mediaType: mediaType.VIDEO},
-          });
-        })
-        .catch((error) => {
-          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.UNMUTE_VIDEO_FAILURE, {
-            correlation_id: this.correlationId,
-            locus_id: this.locusUrl.split('/').pop(),
-            reason: error.message,
-            stack: error.stack,
-          });
-
-          throw error;
-        }),
-      {
-        header: `${LOG_HEADER} unmuting video`,
-        success: `${LOG_HEADER} unmuted video successfully`,
-        failure: `${LOG_HEADER} unmuting video failed, `,
-      }
-    );
-  }
-
   /**
    * Shorthand function to join AND set up media
    * @param {Object} options - options to join with media
    * @param {JoinOptions} [options.joinOptions] - see #join()
-   * @param {MediaDirection} options.mediaSettings - see #addMedia()
-   * @param {AudioVideo} [options.audioVideoOptions] - see #getMediaStreams()
-   * @returns {Promise} -- {join: see join(), media: see addMedia(), local: see getMediaStreams()}
+   * @param {MediaDirection} [options.mediaOptions] - see #addMedia()
+   * @returns {Promise} -- {join: see join(), media: see addMedia()}
    * @public
    * @memberof Meeting
    * @example
    * joinWithMedia({
    *  joinOptions: {resourceId: 'resourceId' },
-   *  mediaSettings: {
-   *   sendAudio: true,
-   *   sendVideo: true,
-   *   sendShare: false,
-   *   receiveVideo:true,
-   *   receiveAudio: true,
-   *   receiveShare: true
-   * }
-   * audioVideoOptions: {
-   *   audio: 'audioDeviceId',
-   *   video: 'videoDeviceId'
-   * }})
+   *  mediaOptions: {
+   *    localTracks: { microphone: microphoneTrack, camera: cameraTrack }
+   *   }
+   * })
    */
   public joinWithMedia(
     options: {
       joinOptions?: any;
-      mediaSettings: any;
-      audioVideoOptions?: any;
-    } = {} as any
+      mediaOptions?: AddMediaOptions;
+    } = {}
   ) {
-    // TODO: add validations for parameters
-    const {mediaSettings, joinOptions, audioVideoOptions} = options;
+    const {mediaOptions, joinOptions} = options;
 
     return this.join(joinOptions)
       .then((joinResponse) =>
-        this.getMediaStreams(mediaSettings, audioVideoOptions).then(([localStream, localShare]) =>
-          this.addMedia({
-            mediaSettings,
-            localShare,
-            localStream,
-          }).then((mediaResponse) => ({
-            join: joinResponse,
-            media: mediaResponse,
-            local: [localStream, localShare],
-          }))
-        )
+        this.addMedia(mediaOptions).then((mediaResponse) => ({
+          join: joinResponse,
+          media: mediaResponse,
+        }))
       )
       .catch((error) => {
         LoggerProxy.logger.error('Meeting:index#joinWithMedia --> ', error);
@@ -3582,6 +3844,20 @@ export default class Meeting extends StatelessWebexPlugin {
     return false;
   }
 
+  /**
+   * Check if the meeting supports the Reactions
+   * @returns {boolean}
+   */
+  isReactionsSupported() {
+    if (this.locusInfo?.controls?.reactions.enabled) {
+      return true;
+    }
+
+    LoggerProxy.logger.error('Meeting:index#isReactionsSupported --> Reactions is not supported');
+
+    return false;
+  }
+
   /**
    * Monitor the Low-Latency Mercury (LLM) web socket connection on `onError` and `onClose` states
    * @private
@@ -3633,6 +3909,7 @@ export default class Meeting extends StatelessWebexPlugin {
       // @ts-ignore - fix type
       const {
         body: {webSocketUrl},
+        // @ts-ignore
       } = await this.request({
         method: HTTP_VERBS.POST,
         uri: datachannelUrl,
@@ -3682,6 +3959,44 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   }
 
+  /**
+   * Callback called when a relay event is received from meeting LLM Connection
+   * @param {RelayEvent} e Event object coming from LLM Connection
+   * @private
+   * @returns {void}
+   */
+  private processRelayEvent = (e: RelayEvent): void => {
+    switch (e.data.relayType) {
+      case REACTION_RELAY_TYPES.REACTION:
+        if (
+          // @ts-ignore - config coming from registerPlugin
+          (this.config.receiveReactions || options.receiveReactions) &&
+          this.isReactionsSupported()
+        ) {
+          const {name} = this.members.membersCollection.get(e.data.sender.participantId);
+          const processedReaction: ProcessedReaction = {
+            reaction: e.data.reaction,
+            sender: {
+              id: e.data.sender.participantId,
+              name,
+            },
+          };
+          Trigger.trigger(
+            this,
+            {
+              file: 'meeting/index',
+              function: 'join',
+            },
+            EVENT_TRIGGERS.MEETING_RECEIVE_REACTIONS,
+            processedReaction
+          );
+        }
+        break;
+      default:
+        break;
+    }
+  };
+
   /**
    * stop recieving Transcription by closing
    * the web socket connection properly
@@ -3753,9 +4068,16 @@ export default class Meeting extends StatelessWebexPlugin {
       joinSuccess = resolve;
     });
 
+    if (options.correlationId) {
+      this.setCorrelationId(options.correlationId);
+      LoggerProxy.logger.log(
+        `Meeting:index#join --> Using a new correlation id from app ${this.correlationId}`
+      );
+    }
+
     if (!this.hasJoinedOnce) {
       this.hasJoinedOnce = true;
-    } else {
+    } else if (!options.correlationId) {
       LoggerProxy.logger.log(
         `Meeting:index#join --> Generating a new correlation id for meeting ${this.id}`
       );
@@ -3776,10 +4098,25 @@ export default class Meeting extends StatelessWebexPlugin {
       data: {trigger: trigger.USER_INTERACTION, isRoapCallEnabled: true},
     });
 
-    LoggerProxy.logger.log('Meeting:index#join --> Joining a meeting');
+    if (!isEmpty(this.meetingInfo)) {
+      Metrics.postEvent({
+        event: eventType.MEETING_INFO_REQUEST,
+        meeting: this,
+      });
 
-    if (this.meetingFiniteStateMachine.state === MEETING_STATE_MACHINE.STATES.ENDED) {
-      this.meetingFiniteStateMachine.reset();
+      Metrics.postEvent({
+        event: eventType.MEETING_INFO_RESPONSE,
+        meeting: this,
+        data: {
+          meetingLookupUrl: this.meetingInfo?.meetingLookupUrl,
+        },
+      });
+    }
+
+    LoggerProxy.logger.log('Meeting:index#join --> Joining a meeting');
+
+    if (this.meetingFiniteStateMachine.state === MEETING_STATE_MACHINE.STATES.ENDED) {
+      this.meetingFiniteStateMachine.reset();
     }
     if (this.meetingFiniteStateMachine.state !== MEETING_STATE_MACHINE.STATES.RINGING) {
       this.meetingFiniteStateMachine.ring(_JOIN_);
@@ -3804,18 +4141,12 @@ export default class Meeting extends StatelessWebexPlugin {
           return Promise.reject(error);
         }
 
-        this.mediaProperties.setLocalQualityLevel(options.meetingQuality);
         this.mediaProperties.setRemoteQualityLevel(options.meetingQuality);
       }
 
       if (typeof options.meetingQuality === 'object') {
-        if (
-          !QUALITY_LEVELS[options.meetingQuality.local] &&
-          !QUALITY_LEVELS[options.meetingQuality.remote]
-        ) {
-          const errorMessage = `Meeting:index#join --> ${
-            options.meetingQuality.local || options.meetingQuality.remote
-          } not defined`;
+        if (!QUALITY_LEVELS[options.meetingQuality.remote]) {
+          const errorMessage = `Meeting:index#join --> ${options.meetingQuality.remote} not defined`;
 
           LoggerProxy.logger.error(errorMessage);
 
@@ -3827,9 +4158,6 @@ export default class Meeting extends StatelessWebexPlugin {
           return Promise.reject(new Error(errorMessage));
         }
 
-        if (options.meetingQuality.local) {
-          this.mediaProperties.setLocalQualityLevel(options.meetingQuality.local);
-        }
         if (options.meetingQuality.remote) {
           this.mediaProperties.setRemoteQualityLevel(options.meetingQuality.remote);
         }
@@ -3855,6 +4183,7 @@ export default class Meeting extends StatelessWebexPlugin {
         return join;
       })
       .then(async (join) => {
+        // @ts-ignore - config coming from registerPlugin
         if (this.config.enableAutomaticLLM) {
           await this.updateLLMConnection();
         }
@@ -3923,22 +4252,41 @@ export default class Meeting extends StatelessWebexPlugin {
    * @returns {Promise}
    */
   async updateLLMConnection() {
+    // @ts-ignore - Fix type
     const {url, info: {datachannelUrl} = {}} = this.locusInfo;
 
-    const isJoined = this.joinedWith && this.joinedWith.state === 'JOINED';
+    const isJoined = this.isJoined();
 
+    // @ts-ignore - Fix type
     if (this.webex.internal.llm.isConnected()) {
+      // @ts-ignore - Fix type
       if (url === this.webex.internal.llm.getLocusUrl() && isJoined) {
         return undefined;
       }
+      // @ts-ignore - Fix type
       await this.webex.internal.llm.disconnectLLM();
+      // @ts-ignore - Fix type
+      this.webex.internal.llm.off('event:relay.event', this.processRelayEvent);
     }
 
     if (!isJoined) {
       return undefined;
     }
 
-    return this.webex.internal.llm.registerAndConnect(url, datachannelUrl);
+    // @ts-ignore - Fix type
+    return this.webex.internal.llm
+      .registerAndConnect(url, datachannelUrl)
+      .then((registerAndConnectResult) => {
+        // @ts-ignore - Fix type
+        this.webex.internal.llm.off('event:relay.event', this.processRelayEvent);
+        // @ts-ignore - Fix type
+        this.webex.internal.llm.on('event:relay.event', this.processRelayEvent);
+        LoggerProxy.logger.info(
+          'Meeting:index#updateLLMConnection --> enabled to receive relay events!'
+        );
+
+        return Promise.resolve(registerAndConnectResult);
+      });
   }
 
   /**
@@ -3980,28 +4328,28 @@ export default class Meeting extends StatelessWebexPlugin {
 
     if (!this.dialInUrl) this.dialInUrl = `dialin:///${uuid.v4()}`;
 
-    return this.meetingRequest
-      .dialIn({
-        correlationId,
-        dialInUrl: this.dialInUrl,
-        locusUrl,
-        clientUrl: this.deviceUrl,
-      })
-      .then((res) => {
-        this.locusInfo.onFullLocus(res.body.locus);
-      })
-      .catch((error) => {
-        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_DIAL_IN_FAILURE, {
-          correlation_id: this.correlationId,
-          dial_in_url: this.dialInUrl,
-          locus_id: locusUrl.split('/').pop(),
-          client_url: this.deviceUrl,
-          reason: error.error?.message,
-          stack: error.stack,
-        });
+    return (
+      this.meetingRequest
+        // @ts-ignore
+        .dialIn({
+          correlationId,
+          dialInUrl: this.dialInUrl,
+          locusUrl,
+          clientUrl: this.deviceUrl,
+        })
+        .catch((error) => {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_DIAL_IN_FAILURE, {
+            correlation_id: this.correlationId,
+            dial_in_url: this.dialInUrl,
+            locus_id: locusUrl.split('/').pop(),
+            client_url: this.deviceUrl,
+            reason: error.error?.message,
+            stack: error.stack,
+          });
 
-        return Promise.reject(error);
-      });
+          return Promise.reject(error);
+        })
+    );
   }
 
   /**
@@ -4018,29 +4366,29 @@ export default class Meeting extends StatelessWebexPlugin {
 
     if (!this.dialOutUrl) this.dialOutUrl = `dialout:///${uuid.v4()}`;
 
-    return this.meetingRequest
-      .dialOut({
-        correlationId,
-        dialOutUrl: this.dialOutUrl,
-        phoneNumber,
-        locusUrl,
-        clientUrl: this.deviceUrl,
-      })
-      .then((res) => {
-        this.locusInfo.onFullLocus(res.body.locus);
-      })
-      .catch((error) => {
-        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_DIAL_OUT_FAILURE, {
-          correlation_id: this.correlationId,
-          dial_out_url: this.dialOutUrl,
-          locus_id: locusUrl.split('/').pop(),
-          client_url: this.deviceUrl,
-          reason: error.error?.message,
-          stack: error.stack,
-        });
+    return (
+      this.meetingRequest
+        // @ts-ignore
+        .dialOut({
+          correlationId,
+          dialOutUrl: this.dialOutUrl,
+          phoneNumber,
+          locusUrl,
+          clientUrl: this.deviceUrl,
+        })
+        .catch((error) => {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_DIAL_OUT_FAILURE, {
+            correlation_id: this.correlationId,
+            dial_out_url: this.dialOutUrl,
+            locus_id: locusUrl.split('/').pop(),
+            client_url: this.deviceUrl,
+            reason: error.error?.message,
+            stack: error.stack,
+          });
 
-        return Promise.reject(error);
-      });
+          return Promise.reject(error);
+        })
+    );
   }
 
   /**
@@ -4116,14 +4464,10 @@ export default class Meeting extends StatelessWebexPlugin {
           },
         };
 
-        // clean up the local tracks
-        this.mediaProperties.setMediaDirection(mediaSettings.mediaDirection);
-
-        // close the existing local tracks
-        await this.closeLocalStream();
-        await this.closeLocalShare();
+        this.cleanupLocalTracks();
 
-        this.mediaProperties.unsetMediaTracks();
+        this.mediaProperties.setMediaDirection(mediaSettings.mediaDirection);
+        this.mediaProperties.unsetRemoteMedia();
 
         // when a move to is intiated by the client , Locus delets the existing media node from the server as soon the DX answers the meeting
         // once the DX answers we establish connection back the media server with only receiveShare enabled
@@ -4206,165 +4550,6 @@ export default class Meeting extends StatelessWebexPlugin {
       });
   }
 
-  /**
-   * Get local media streams based on options passed
-   *
-   * NOTE: this method can only be used with transcoded meetings, not with multistream meetings
-   *
-   * @param {MediaDirection} mediaDirection A configurable options object for joining a meeting
-   * @param {AudioVideo} [audioVideo] audio/video object to set audioinput and videoinput devices, see #Media.getUserMedia
-   * @param {SharePreferences} [sharePreferences] audio/video object to set audioinput and videoinput devices, see #Media.getUserMedia
-   * @returns {Promise} see #Media.getUserMedia
-   * @public
-   * @todo should be static, or moved so can be called outside of a meeting
-   * @memberof Meeting
-   */
-  getMediaStreams = (
-    mediaDirection: any,
-    // This return an OBJECT {video: {height, widght}}
-    // eslint-disable-next-line default-param-last
-    audioVideo: any = VIDEO_RESOLUTIONS[this.mediaProperties.localQualityLevel],
-    sharePreferences?: any
-  ) => {
-    if (
-      mediaDirection &&
-      (mediaDirection.sendAudio || mediaDirection.sendVideo || mediaDirection.sendShare)
-    ) {
-      if (
-        mediaDirection &&
-        mediaDirection.sendAudio &&
-        mediaDirection.sendVideo &&
-        mediaDirection.sendShare &&
-        isBrowser('safari')
-      ) {
-        LoggerProxy.logger.warn(
-          'Meeting:index#getMediaStreams --> Setting `sendShare` to FALSE, due to complications with Safari'
-        );
-
-        mediaDirection.sendShare = false;
-
-        LoggerProxy.logger.warn(
-          'Meeting:index#getMediaStreams --> Enabling `sendShare` along with `sendAudio` & `sendVideo`, on Safari, causes a failure while setting up a screen share at the same time as the camera+mic stream'
-        );
-        LoggerProxy.logger.warn(
-          'Meeting:index#getMediaStreams --> Please use `meeting.shareScreen()` to manually start the screen share after successfully joining the meeting'
-        );
-      }
-
-      if (audioVideo && isString(audioVideo)) {
-        if (Object.keys(VIDEO_RESOLUTIONS).includes(audioVideo)) {
-          this.mediaProperties.setLocalQualityLevel(audioVideo);
-          audioVideo = {video: VIDEO_RESOLUTIONS[audioVideo].video};
-        } else {
-          throw new ParameterError(
-            `${audioVideo} not supported. Either pass level from pre-defined resolutions or pass complete audioVideo object`
-          );
-        }
-      }
-
-      if (!audioVideo.video) {
-        audioVideo = {
-          ...audioVideo,
-          video: {
-            ...audioVideo.video,
-            ...VIDEO_RESOLUTIONS[this.mediaProperties.localQualityLevel].video,
-          },
-        };
-      }
-      // extract deviceId if exists otherwise default to null.
-      const {deviceId: preferredVideoDevice} = (audioVideo && audioVideo.video) || {deviceId: null};
-      const lastVideoDeviceId = this.mediaProperties.getVideoDeviceId();
-
-      if (preferredVideoDevice) {
-        // Store new preferred video input device
-        this.mediaProperties.setVideoDeviceId(preferredVideoDevice);
-      } else if (lastVideoDeviceId) {
-        // no new video preference specified so use last stored value,
-        // works with empty object {} or media constraint.
-        // eslint-disable-next-line no-param-reassign
-        audioVideo = {
-          ...audioVideo,
-          video: {
-            ...audioVideo.video,
-            deviceId: lastVideoDeviceId,
-          },
-        };
-      }
-
-      return Media.getSupportedDevice({
-        sendAudio: mediaDirection.sendAudio,
-        sendVideo: mediaDirection.sendVideo,
-      })
-        .catch((error) =>
-          Promise.reject(
-            new MediaError(
-              'Given constraints do not match permission set for either camera or microphone',
-              error
-            )
-          )
-        )
-        .then((devicePermissions) =>
-          Media.getUserMedia(
-            {
-              ...mediaDirection,
-              sendAudio: devicePermissions.sendAudio,
-              sendVideo: devicePermissions.sendVideo,
-              isSharing: this.shareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE,
-            },
-            audioVideo,
-            sharePreferences,
-            // @ts-ignore - config coming from registerPlugin
-            this.config
-          ).catch((error) => {
-            // Whenever there is a failure when trying to access a user's device
-            // report it as an Behavioral metric
-            // This gives visibility into common errors and can help
-            // with further troubleshooting
-            const metricName = BEHAVIORAL_METRICS.GET_USER_MEDIA_FAILURE;
-            const data = {
-              correlation_id: this.correlationId,
-              locus_id: this.locusUrl?.split('/').pop(),
-              reason: error.message,
-              stack: error.stack,
-            };
-            const metadata = {
-              type: error.name,
-            };
-
-            Metrics.sendBehavioralMetric(metricName, data, metadata);
-            throw new MediaError('Unable to retrieve media streams', error);
-          })
-        );
-    }
-
-    return Promise.reject(
-      new MediaError('At least one of the mediaDirection value should be true')
-    );
-  };
-
-  /**
-   * Checks if the machine has at least one audio or video device
-   * @param {Object} options
-   * @param {Boolean} options.sendAudio
-   * @param {Boolean} options.sendVideo
-   * @returns {Object}
-   * @memberof Meetings
-   */
-  getSupportedDevices = ({
-    sendAudio = true,
-    sendVideo = true,
-  }: {
-    sendAudio: boolean;
-    sendVideo: boolean;
-  }) => Media.getSupportedDevice({sendAudio, sendVideo});
-
-  /**
-   * Get the devices from the Media module
-   * @returns {Promise} resolves to an array of DeviceInfo
-   * @memberof Meetings
-   */
-  getDevices = () => Media.getDevices();
-
   /**
    * Handles ROAP_FAILURE event from the webrtc media connection
    *
@@ -4387,7 +4572,7 @@ export default class Meeting extends StatelessWebexPlugin {
       Metrics.sendBehavioralMetric(metricName, data, metadata);
     };
 
-    if (error instanceof MC.Errors.SdpOfferCreationError) {
+    if (error instanceof Errors.SdpOfferCreationError) {
       sendBehavioralMetric(BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE, error, this.id);
 
       Metrics.postEvent({
@@ -4401,8 +4586,8 @@ export default class Meeting extends StatelessWebexPlugin {
         },
       });
     } else if (
-      error instanceof MC.Errors.SdpOfferHandlingError ||
-      error instanceof MC.Errors.SdpAnswerHandlingError
+      error instanceof Errors.SdpOfferHandlingError ||
+      error instanceof Errors.SdpAnswerHandlingError
     ) {
       sendBehavioralMetric(BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE, error, this.id);
 
@@ -4416,8 +4601,8 @@ export default class Meeting extends StatelessWebexPlugin {
           ],
         },
       });
-    } else if (error instanceof MC.Errors.SdpError) {
-      // this covers also the case of MC.Errors.IceGatheringError which extends MC.Errors.SdpError
+    } else if (error instanceof Errors.SdpError) {
+      // this covers also the case of Errors.IceGatheringError which extends Errors.SdpError
       sendBehavioralMetric(BEHAVIORAL_METRICS.INVALID_ICE_CANDIDATE, error, this.id);
 
       Metrics.postEvent({
@@ -4434,20 +4619,20 @@ export default class Meeting extends StatelessWebexPlugin {
   };
 
   setupMediaConnectionListeners = () => {
-    this.mediaProperties.webrtcMediaConnection.on(MC.Event.ROAP_STARTED, () => {
+    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_STARTED, () => {
       this.isRoapInProgress = true;
     });
 
-    this.mediaProperties.webrtcMediaConnection.on(MC.Event.ROAP_DONE, () => {
+    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_DONE, () => {
       this.mediaNegotiatedEvent();
       this.isRoapInProgress = false;
       this.processNextQueuedMediaUpdate();
     });
 
-    this.mediaProperties.webrtcMediaConnection.on(MC.Event.ROAP_FAILURE, this.handleRoapFailure);
+    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_FAILURE, this.handleRoapFailure);
 
-    this.mediaProperties.webrtcMediaConnection.on(MC.Event.ROAP_MESSAGE_TO_SEND, (event) => {
-      const LOG_HEADER = 'Meeting:index#setupMediaConnectionListeners.ROAP_MESSAGE_TO_SEND -->';
+    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_MESSAGE_TO_SEND, (event) => {
+      const LOG_HEADER = `Meeting:index#setupMediaConnectionListeners.ROAP_MESSAGE_TO_SEND --> correlationId=${this.correlationId}`;
 
       switch (event.roapMessage.messageType) {
         case 'OK':
@@ -4463,9 +4648,7 @@ export default class Meeting extends StatelessWebexPlugin {
               correlationId: this.correlationId,
             }),
             {
-              header: `${LOG_HEADER} Send Roap OK`,
-              success: `${LOG_HEADER} Successfully send roap OK`,
-              failure: `${LOG_HEADER} Error joining the call on send roap OK, `,
+              logText: `${LOG_HEADER} Roap OK`,
             }
           );
           break;
@@ -4485,9 +4668,7 @@ export default class Meeting extends StatelessWebexPlugin {
               reconnect: this.reconnectionManager.isReconnectInProgress(),
             }),
             {
-              header: `${LOG_HEADER} Send Roap Offer`,
-              success: `${LOG_HEADER} Successfully send roap offer`,
-              failure: `${LOG_HEADER} Error joining the call on send roap offer, `,
+              logText: `${LOG_HEADER} Roap Offer`,
             }
           );
           break;
@@ -4506,9 +4687,7 @@ export default class Meeting extends StatelessWebexPlugin {
               correlationId: this.correlationId,
             }),
             {
-              header: `${LOG_HEADER} Send Roap Answer.`,
-              success: `${LOG_HEADER} Successfully send roap answer`,
-              failure: `${LOG_HEADER} Error joining the call on send roap answer, `,
+              logText: `${LOG_HEADER} Roap Answer`,
             }
           ).catch((error) => {
             const metricName = BEHAVIORAL_METRICS.ROAP_ANSWER_FAILURE;
@@ -4528,8 +4707,8 @@ export default class Meeting extends StatelessWebexPlugin {
 
         case 'ERROR':
           if (
-            event.roapMessage.errorType === MC.ErrorType.CONFLICT ||
-            event.roapMessage.errorType === MC.ErrorType.DOUBLECONFLICT
+            event.roapMessage.errorType === ErrorType.CONFLICT ||
+            event.roapMessage.errorType === ErrorType.DOUBLECONFLICT
           ) {
             Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_GLARE_CONDITION, {
               correlation_id: this.correlationId,
@@ -4545,9 +4724,7 @@ export default class Meeting extends StatelessWebexPlugin {
               correlationId: this.correlationId,
             }),
             {
-              header: `${LOG_HEADER} Send Roap Error.`,
-              success: `${LOG_HEADER} Successfully send roap error`,
-              failure: `${LOG_HEADER} Failed to send roap error, `,
+              logText: `${LOG_HEADER} Roap Error (${event.roapMessage.errorType})`,
             }
           );
           break;
@@ -4561,7 +4738,7 @@ export default class Meeting extends StatelessWebexPlugin {
     });
 
     // eslint-disable-next-line no-param-reassign
-    this.mediaProperties.webrtcMediaConnection.on(MC.Event.REMOTE_TRACK_ADDED, (event) => {
+    this.mediaProperties.webrtcMediaConnection.on(Event.REMOTE_TRACK_ADDED, (event) => {
       LoggerProxy.logger.log(
         `Meeting:index#setupMediaConnectionListeners --> REMOTE_TRACK_ADDED event received for webrtcMediaConnection: ${JSON.stringify(
           event
@@ -4574,15 +4751,15 @@ export default class Meeting extends StatelessWebexPlugin {
       let eventType;
 
       switch (event.type) {
-        case MC.RemoteTrackType.AUDIO:
+        case RemoteTrackType.AUDIO:
           eventType = EVENT_TYPES.REMOTE_AUDIO;
           this.mediaProperties.setRemoteAudioTrack(event.track);
           break;
-        case MC.RemoteTrackType.VIDEO:
+        case RemoteTrackType.VIDEO:
           eventType = EVENT_TYPES.REMOTE_VIDEO;
           this.mediaProperties.setRemoteVideoTrack(event.track);
           break;
-        case MC.RemoteTrackType.SCREENSHARE_VIDEO:
+        case RemoteTrackType.SCREENSHARE_VIDEO:
           if (event.track) {
             eventType = EVENT_TYPES.REMOTE_SHARE;
             this.mediaProperties.setRemoteShare(event.track);
@@ -4595,10 +4772,6 @@ export default class Meeting extends StatelessWebexPlugin {
         }
       }
 
-      // start stats here the stats are coming null if you dont receive streams
-
-      this.statsAnalyzer.startAnalyzer(this.mediaProperties.webrtcMediaConnection);
-
       if (eventType && mediaTrack) {
         Trigger.trigger(
           this,
@@ -4615,7 +4788,7 @@ export default class Meeting extends StatelessWebexPlugin {
       }
     });
 
-    this.mediaProperties.webrtcMediaConnection.on(MC.Event.CONNECTION_STATE_CHANGED, (event) => {
+    this.mediaProperties.webrtcMediaConnection.on(Event.CONNECTION_STATE_CHANGED, (event) => {
       const connectionFailed = () => {
         // we know the media connection failed and browser will not attempt to recover it any more
         // so reset the timer as it's not needed anymore, we want to reconnect immediately
@@ -4645,13 +4818,13 @@ export default class Meeting extends StatelessWebexPlugin {
       };
 
       LoggerProxy.logger.info(
-        `Meeting:index#setupMediaConnectionListeners --> connection state changed to ${event.state}`
+        `Meeting:index#setupMediaConnectionListeners --> correlationId=${this.correlationId} connection state changed to ${event.state}`
       );
       switch (event.state) {
-        case MC.ConnectionState.Connecting:
+        case ConnectionState.Connecting:
           Metrics.postEvent({event: eventType.ICE_START, meeting: this});
           break;
-        case MC.ConnectionState.Connected:
+        case ConnectionState.Connected:
           Metrics.postEvent({event: eventType.ICE_END, meeting: this});
           Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.CONNECTION_SUCCESS, {
             correlation_id: this.correlationId,
@@ -4659,8 +4832,9 @@ export default class Meeting extends StatelessWebexPlugin {
           });
           this.setNetworkStatus(NETWORK_STATUS.CONNECTED);
           this.reconnectionManager.iceReconnected();
+          this.statsAnalyzer.startAnalyzer(this.mediaProperties.webrtcMediaConnection);
           break;
-        case MC.ConnectionState.Disconnected:
+        case ConnectionState.Disconnected:
           this.setNetworkStatus(NETWORK_STATUS.DISCONNECTED);
           this.reconnectionManager.waitForIceReconnect().catch(() => {
             LoggerProxy.logger.info(
@@ -4670,7 +4844,7 @@ export default class Meeting extends StatelessWebexPlugin {
             connectionFailed();
           });
           break;
-        case MC.ConnectionState.Failed:
+        case ConnectionState.Failed:
           connectionFailed();
           break;
         default:
@@ -4678,7 +4852,7 @@ export default class Meeting extends StatelessWebexPlugin {
       }
     });
 
-    this.mediaProperties.webrtcMediaConnection.on(MC.Event.ACTIVE_SPEAKERS_CHANGED, (msg) => {
+    this.mediaProperties.webrtcMediaConnection.on(Event.ACTIVE_SPEAKERS_CHANGED, (msg) => {
       Trigger.trigger(
         this,
         {
@@ -4689,6 +4863,7 @@ export default class Meeting extends StatelessWebexPlugin {
         {
           seqNum: msg.seqNum,
           memberIds: msg.csis
+            // @ts-ignore
             .map((csi) => this.members.findMemberByCsi(csi)?.id)
             .filter((item) => item !== undefined),
         }
@@ -4696,8 +4871,8 @@ export default class Meeting extends StatelessWebexPlugin {
     });
 
     this.mediaProperties.webrtcMediaConnection.on(
-      MC.Event.VIDEO_SOURCES_COUNT_CHANGED,
-      (numTotalSources, numLiveSources) => {
+      Event.VIDEO_SOURCES_COUNT_CHANGED,
+      (numTotalSources, numLiveSources, mediaContent) => {
         Trigger.trigger(
           this,
           {
@@ -4708,14 +4883,19 @@ export default class Meeting extends StatelessWebexPlugin {
           {
             numTotalSources,
             numLiveSources,
+            mediaContent,
           }
         );
+
+        if (mediaContent === MediaContent.Main) {
+          this.mediaRequestManagers.video.setNumCurrentSources(numTotalSources, numLiveSources);
+        }
       }
     );
 
     this.mediaProperties.webrtcMediaConnection.on(
-      MC.Event.AUDIO_SOURCES_COUNT_CHANGED,
-      (numTotalSources, numLiveSources) => {
+      Event.AUDIO_SOURCES_COUNT_CHANGED,
+      (numTotalSources, numLiveSources, mediaContent) => {
         Trigger.trigger(
           this,
           {
@@ -4726,6 +4906,7 @@ export default class Meeting extends StatelessWebexPlugin {
           {
             numTotalSources,
             numLiveSources,
+            mediaContent,
           }
         );
       }
@@ -4744,6 +4925,7 @@ export default class Meeting extends StatelessWebexPlugin {
       // Add ip address info if geo hint is present
       // @ts-ignore fix type
       options.data.intervalMetadata.peerReflexiveIP =
+        // @ts-ignore
         this.webex.meetings.geoHintInfo?.clientAddress ||
         options.data.intervalMetadata.peerReflexiveIP ||
         MQA_STATS.DEFAULT_IP;
@@ -4813,7 +4995,15 @@ export default class Meeting extends StatelessWebexPlugin {
     return `MC-${this.id.substring(0, 4)}`;
   }
 
-  createMediaConnection(turnServerInfo) {
+  /**
+   * Creates a webrtc media connection and publishes tracks to it
+   *
+   * @param {Object} turnServerInfo TURN server information
+   * @param {BundlePolicy} [bundlePolicy] Bundle policy settings
+   * @returns {RoapMediaConnection | MultistreamRoapMediaConnection}
+   */
+  private async createMediaConnection(turnServerInfo, bundlePolicy?: BundlePolicy) {
+    // create the actual media connection
     const mc = Media.createMediaConnection(this.isMultistream, this.getMediaConnectionDebugId(), {
       mediaProperties: this.mediaProperties,
       remoteQualityLevel: this.mediaProperties.remoteQualityLevel,
@@ -4822,11 +5012,23 @@ export default class Meeting extends StatelessWebexPlugin {
       // @ts-ignore - config coming from registerPlugin
       enableExtmap: this.config.enableExtmap,
       turnServerInfo,
+      bundlePolicy,
     });
 
     this.mediaProperties.setMediaPeerConnection(mc);
     this.setupMediaConnectionListeners();
 
+    // publish the tracks
+    if (this.mediaProperties.audioTrack) {
+      await this.publishTrack(this.mediaProperties.audioTrack);
+    }
+    if (this.mediaProperties.videoTrack) {
+      await this.publishTrack(this.mediaProperties.videoTrack);
+    }
+    if (this.mediaProperties.shareTrack) {
+      await this.publishTrack(this.mediaProperties.shareTrack);
+    }
+
     return mc;
   }
 
@@ -4854,23 +5056,21 @@ export default class Meeting extends StatelessWebexPlugin {
   }
 
   /**
-   * Specify joining via audio (option: pstn), video, screenshare
-   * @param {Object} options A configurable options object for joining a meeting
-   * @param {Object} options.resourceId pass the deviceId
-   * @param {MediaDirection} options.mediaSettings pass media options
-   * @param {MediaStream} options.localStream
-   * @param {MediaStream} options.localShare
-   * @param {RemoteMediaManagerConfig} options.remoteMediaManagerConfig only applies if multistream is enabled
+   * Creates a media connection to the server. Media connection is required for sending or receiving any audio/video.
+   *
+   * @param {AddMediaOptions} options
    * @returns {Promise}
    * @public
    * @memberof Meeting
    */
-  addMedia(options: any = {}) {
+  addMedia(options: AddMediaOptions = {}) {
     const LOG_HEADER = 'Meeting:index#addMedia -->';
 
     let turnDiscoverySkippedReason;
     let turnServerUsed = false;
 
+    LoggerProxy.logger.info(`${LOG_HEADER} called with: ${JSON.stringify(options)}`);
+
     if (this.meetingState !== FULL_STATE.ACTIVE) {
       return Promise.reject(new MeetingNotActiveError());
     }
@@ -4884,9 +5084,14 @@ export default class Meeting extends StatelessWebexPlugin {
       return Promise.reject(new UserInLobbyError());
     }
 
-    const {localStream, localShare, mediaSettings, remoteMediaManagerConfig} = options;
-
-    LoggerProxy.logger.info(`${LOG_HEADER} Adding Media.`);
+    const {
+      localTracks,
+      audioEnabled = true,
+      videoEnabled = true,
+      receiveShare = true,
+      remoteMediaManagerConfig,
+      bundlePolicy,
+    } = options;
 
     Metrics.postEvent({
       event: eventType.MEDIA_CAPABILITIES,
@@ -4911,17 +5116,61 @@ export default class Meeting extends StatelessWebexPlugin {
       },
     });
 
-    return MeetingUtil.validateOptions(options)
+    // when audioEnabled/videoEnabled is true, we set sendAudio/sendVideo to true even before any tracks are published
+    // to avoid doing an extra SDP exchange when they are published for the first time
+    this.mediaProperties.setMediaDirection({
+      sendAudio: audioEnabled,
+      sendVideo: videoEnabled,
+      sendShare: false,
+      receiveAudio: audioEnabled,
+      receiveVideo: videoEnabled,
+      receiveShare,
+    });
+
+    this.locusMediaRequest = new LocusMediaRequest(
+      {
+        correlationId: this.correlationId,
+        device: {
+          url: this.deviceUrl,
+          // @ts-ignore
+          deviceType: this.config.deviceType,
+        },
+        preferTranscoding: !this.isMultistream,
+      },
+      {
+        // @ts-ignore
+        parent: this.webex,
+      }
+    );
+
+    this.audio = createMuteState(AUDIO, this, audioEnabled);
+    this.video = createMuteState(VIDEO, this, videoEnabled);
+
+    this.annotationInfo = localTracks?.annotationInfo;
+
+    const promises = [];
+
+    // setup all the references to local tracks in this.mediaProperties before creating media connection
+    // and before TURN discovery, so that the correct mute state is sent with TURN discovery roap messages
+    if (localTracks?.microphone) {
+      promises.push(this.setLocalAudioTrack(localTracks.microphone));
+    }
+    if (localTracks?.camera) {
+      promises.push(this.setLocalVideoTrack(localTracks.camera));
+    }
+    if (localTracks?.screenShare?.video) {
+      promises.push(this.setLocalShareTrack(localTracks.screenShare.video));
+    }
+
+    return Promise.all(promises)
       .then(() => this.roap.doTurnDiscovery(this, false))
-      .then((turnDiscoveryObject) => {
+      .then(async (turnDiscoveryObject) => {
         ({turnDiscoverySkippedReason} = turnDiscoveryObject);
         turnServerUsed = !turnDiscoverySkippedReason;
 
         const {turnServerInfo} = turnDiscoveryObject;
 
-        this.preMedia(localStream, localShare, mediaSettings);
-
-        const mc = this.createMediaConnection(turnServerInfo);
+        const mc = await this.createMediaConnection(turnServerInfo, bundlePolicy);
 
         if (this.isMultistream) {
           this.remoteMediaManager = new RemoteMediaManager(
@@ -4946,18 +5195,21 @@ export default class Meeting extends StatelessWebexPlugin {
             EVENT_TRIGGERS.REMOTE_MEDIA_VIDEO_LAYOUT_CHANGED
           );
 
-          return this.remoteMediaManager.start().then(() => mc.initiateOffer());
+          await this.remoteMediaManager.start();
         }
 
-        return mc.initiateOffer();
+        await mc.initiateOffer();
       })
       .then(() => {
         this.setMercuryListener();
       })
-      .then(() =>
-        this.getDevices().then((devices) => {
-          MeetingUtil.handleDeviceLogging(devices);
-        })
+      .then(
+        () =>
+          getDevices()
+            .then((devices) => {
+              MeetingUtil.handleDeviceLogging(devices);
+            })
+            .catch(() => {}) // getDevices may fail if we don't have browser permissions, that's ok, we still can have a media connection
       )
       .then(() => {
         this.handleMediaLogging(this.mediaProperties);
@@ -4967,8 +5219,12 @@ export default class Meeting extends StatelessWebexPlugin {
         if (this.config.stats.enableStatsAnalyzer) {
           // @ts-ignore - config coming from registerPlugin
           this.networkQualityMonitor = new NetworkQualityMonitor(this.config.stats);
-          // @ts-ignore - config coming from registerPlugin
-          this.statsAnalyzer = new StatsAnalyzer(this.config.stats, this.networkQualityMonitor);
+          this.statsAnalyzer = new StatsAnalyzer(
+            // @ts-ignore - config coming from registerPlugin
+            this.config.stats,
+            (ssrc: number) => this.receiveSlotManager.findReceiveSlotBySsrc(ssrc),
+            this.networkQualityMonitor
+          );
           this.setupStatsAnalyzerEventHandlers();
           this.networkQualityMonitor.on(
             EVENT_TRIGGERS.NETWORK_QUALITY,
@@ -4991,7 +5247,7 @@ export default class Meeting extends StatelessWebexPlugin {
 
             // eslint-disable-next-line func-names
             // eslint-disable-next-line prefer-arrow-callback
-            if (this.type === _CALL_) {
+            if (this.type === _CALL_ || this.meetingState === FULL_STATE.ACTIVE) {
               resolve();
             }
             const joiningTimer = setInterval(() => {
@@ -5010,21 +5266,15 @@ export default class Meeting extends StatelessWebexPlugin {
       )
       .then(() =>
         this.mediaProperties.waitForMediaConnectionConnected().catch(() => {
-          throw createMeetingsError(30202, 'Meeting connection failed');
+          throw new Error(
+            `Timed out waiting for media connection to be connected, correlationId=${this.correlationId}`
+          );
         })
       )
       .then(() => {
-        LoggerProxy.logger.info(`${LOG_HEADER} PeerConnection CONNECTED`);
-        if (mediaSettings && mediaSettings.sendShare && localShare) {
-          if (this.state === MEETING_STATE.STATES.JOINED) {
-            return this.requestScreenShareFloor();
-          }
-
-          // When the self state changes to JOINED then request the floor
-          this.floorGrantPending = true;
+        if (localTracks?.screenShare?.video) {
+          this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.SHARE_FLOOR_REQUEST);
         }
-
-        return {};
       })
       .then(() => this.mediaProperties.getCurrentConnectionType())
       .then((connectionType) => {
@@ -5032,9 +5282,36 @@ export default class Meeting extends StatelessWebexPlugin {
           correlation_id: this.correlationId,
           locus_id: this.locusUrl.split('/').pop(),
           connectionType,
+          isMultistream: this.isMultistream,
         });
       })
       .catch((error) => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
+          correlation_id: this.correlationId,
+          locus_id: this.locusUrl.split('/').pop(),
+          reason: error.message,
+          stack: error.stack,
+          code: error.code,
+          turnDiscoverySkippedReason,
+          turnServerUsed,
+          isMultistream: this.isMultistream,
+          signalingState:
+            this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
+              ?.signalingState ||
+            this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.signalingState ||
+            'unknown',
+          connectionState:
+            this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
+              ?.connectionState ||
+            this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.connectionState ||
+            'unknown',
+          iceConnectionState:
+            this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
+              ?.iceConnectionState ||
+            this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.iceConnectionState ||
+            'unknown',
+        });
+
         // Clean up stats analyzer, peer connection, and turn off listeners
         const stopStatsAnalyzer = this.statsAnalyzer
           ? this.statsAnalyzer.stopAnalyzer()
@@ -5053,16 +5330,6 @@ export default class Meeting extends StatelessWebexPlugin {
             error
           );
 
-          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
-            correlation_id: this.correlationId,
-            locus_id: this.locusUrl.split('/').pop(),
-            reason: error.message,
-            stack: error.stack,
-            code: error.code,
-            turnDiscoverySkippedReason,
-            turnServerUsed,
-          });
-
           // Upload logs on error while adding media
           Trigger.trigger(
             this,
@@ -5074,7 +5341,7 @@ export default class Meeting extends StatelessWebexPlugin {
             this
           );
 
-          if (error instanceof MC.Errors.SdpError) {
+          if (error instanceof Errors.SdpError) {
             this.leave({reason: MEETING_REMOVED_REASON.MEETING_CONNECTION_FAILED});
           }
 
@@ -5102,7 +5369,9 @@ export default class Meeting extends StatelessWebexPlugin {
    * @private
    * @memberof Meeting
    */
-  private enqueueMediaUpdate(mediaUpdateType: string, options: object) {
+  private enqueueMediaUpdate(mediaUpdateType: string, options: any = {}): Promise<void> {
+    const canUpdateMediaNow = this.canUpdateMedia();
+
     return new Promise((resolve, reject) => {
       const queueItem = {
         pendingPromiseResolve: resolve,
@@ -5115,6 +5384,10 @@ export default class Meeting extends StatelessWebexPlugin {
         `Meeting:index#enqueueMediaUpdate --> enqueuing media update type=${mediaUpdateType}`
       );
       this.queuedMediaUpdates.push(queueItem);
+
+      if (canUpdateMediaNow) {
+        this.processNextQueuedMediaUpdate();
+      }
     });
   }
 
@@ -5154,18 +5427,17 @@ export default class Meeting extends StatelessWebexPlugin {
       LoggerProxy.logger.log(
         `Meeting:index#processNextQueuedMediaUpdate --> performing delayed media update type=${mediaUpdateType}`
       );
+      let mediaUpdate = Promise.resolve();
+
       switch (mediaUpdateType) {
-        case MEDIA_UPDATE_TYPE.ALL:
-          this.updateMedia(options).then(pendingPromiseResolve, pendingPromiseReject);
-          break;
-        case MEDIA_UPDATE_TYPE.AUDIO:
-          this.updateAudio(options).then(pendingPromiseResolve, pendingPromiseReject);
+        case MEDIA_UPDATE_TYPE.TRANSCODED_MEDIA_CONNECTION:
+          mediaUpdate = this.updateTranscodedMediaConnection();
           break;
-        case MEDIA_UPDATE_TYPE.VIDEO:
-          this.updateVideo(options).then(pendingPromiseResolve, pendingPromiseReject);
+        case MEDIA_UPDATE_TYPE.SHARE_FLOOR_REQUEST:
+          mediaUpdate = this.requestScreenShareFloor();
           break;
-        case MEDIA_UPDATE_TYPE.SHARE:
-          this.updateShare(options).then(pendingPromiseResolve, pendingPromiseReject);
+        case MEDIA_UPDATE_TYPE.UPDATE_MEDIA:
+          mediaUpdate = this.updateMedia(options);
           break;
         default:
           LoggerProxy.logger.error(
@@ -5173,329 +5445,84 @@ export default class Meeting extends StatelessWebexPlugin {
           );
           break;
       }
+
+      mediaUpdate
+        .then(pendingPromiseResolve, pendingPromiseReject)
+        .then(() => this.processNextQueuedMediaUpdate());
     }
   };
 
   /**
-   * A confluence of updateAudio, updateVideo, and updateShare
-   * this function re-establishes all of the media streams with new options
+   * Updates the media connection - it allows to enable/disable all audio/video/share in the meeting.
+   * This does not affect the published tracks, so for example if a microphone track is published and
+   * updateMedia({audioEnabled: false}) is called, the audio will not be sent or received anymore,
+   * but the track's "published" state is not changed and when updateMedia({audioEnabled: true}) is called,
+   * the sending of the audio from the same track will resume.
+   *
    * @param {Object} options
-   * @param {MediaStream} options.localStream
-   * @param {MediaStream} options.localShare
-   * @param {MediaDirection} options.mediaSettings
+   * @param {boolean} options.audioEnabled [optional] enables/disables receiving and sending of main audio in the meeting
+   * @param {boolean} options.videoEnabled [optional] enables/disables receiving and sending of main video in the meeting
+   * @param {boolean} options.shareEnabled [optional] enables/disables receiving and sending of screen share in the meeting
    * @returns {Promise}
    * @public
    * @memberof Meeting
    */
-  public updateMedia(
-    options: {
-      localStream?: MediaStream;
-      localShare?: MediaStream;
-      mediaSettings?: any;
-    } = {} as any
-  ) {
-    const LOG_HEADER = 'Meeting:index#updateMedia -->';
+  public async updateMedia(options: {
+    audioEnabled?: boolean;
+    videoEnabled?: boolean;
+    receiveShare?: boolean;
+  }) {
+    this.checkMediaConnection();
 
-    if (!this.canUpdateMedia()) {
-      return this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.ALL, options);
-    }
-    const {localStream, localShare, mediaSettings} = options;
+    const {audioEnabled, videoEnabled, receiveShare} = options;
 
-    const previousSendShareStatus = this.mediaProperties.mediaDirection.sendShare;
+    LoggerProxy.logger.log(
+      `Meeting:index#updateMedia --> called with options=${JSON.stringify(options)}`
+    );
 
-    if (!this.mediaProperties.webrtcMediaConnection) {
-      return Promise.reject(new Error('media connection not established, call addMedia() first'));
+    if (!this.canUpdateMedia()) {
+      return this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.UPDATE_MEDIA, options);
     }
 
-    return MeetingUtil.validateOptions(options)
-      .then(() => this.preMedia(localStream, localShare, mediaSettings))
-      .then(() =>
-        this.mediaProperties.webrtcMediaConnection
-          .updateSendReceiveOptions({
-            send: {
-              audio: this.mediaProperties.mediaDirection.sendAudio
-                ? this.mediaProperties.audioTrack
-                : null,
-              video: this.mediaProperties.mediaDirection.sendVideo
-                ? this.mediaProperties.videoTrack
-                : null,
-              screenShareVideo: this.mediaProperties.mediaDirection.sendShare
-                ? this.mediaProperties.shareTrack
-                : null,
-            },
-            receive: {
-              audio: this.mediaProperties.mediaDirection.receiveAudio,
-              video: this.mediaProperties.mediaDirection.receiveVideo,
-              screenShareVideo: this.mediaProperties.mediaDirection.receiveShare,
-              remoteQualityLevel: this.mediaProperties.remoteQualityLevel,
-            },
-          })
-          .then(() => {
-            LoggerProxy.logger.info(
-              `${LOG_HEADER} webrtcMediaConnection.updateSendReceiveOptions done`
-            );
-          })
-          .catch((error) => {
-            LoggerProxy.logger.error(`${LOG_HEADER} Error updatedMedia, `, error);
-
-            Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.UPDATE_MEDIA_FAILURE, {
-              correlation_id: this.correlationId,
-              locus_id: this.locusUrl.split('/').pop(),
-              reason: error.message,
-              stack: error.stack,
-            });
-
-            throw error;
-          })
-          // todo: the following code used to be called always after sending the roap message with the new SDP
-          // now it's called independently from the roap message (so might be before it), check if that's OK
-          // if not, ensure it's called after (now it's called after roap message is sent out, but we're not
-          // waiting for sendRoapMediaRequest() to be resolved)
-          .then(() => this.checkForStopShare(mediaSettings.sendShare, previousSendShareStatus))
-          .then((startShare) => {
-            // This is a special case if we do an /floor grant followed by /media
-            // we actually get a OFFER from the server and a GLAR condition happens
-            if (startShare) {
-              // We are assuming that the clients are connected when doing an update
-              return this.requestScreenShareFloor();
-            }
-
-            return Promise.resolve();
-          })
-      );
-  }
+    if (this.isMultistream) {
+      if (videoEnabled !== undefined) {
+        throw new Error(
+          'enabling/disabling video in a meeting is not supported for multistream, it can only be done upfront when calling addMedia()'
+        );
+      }
 
-  /**
-   * Update the main audio track with new parameters
-   *
-   * NOTE: this method can only be used with transcoded meetings, for multistream meetings use publishTrack()
-   *
-   * @param {Object} options
-   * @param {boolean} options.sendAudio
-   * @param {boolean} options.receiveAudio
-   * @param {MediaStream} options.stream Stream that contains the audio track to update
-   * @returns {Promise}
-   * @public
-   * @memberof Meeting
-   */
-  public async updateAudio(options: {
-    sendAudio: boolean;
-    receiveAudio: boolean;
-    stream: MediaStream;
-  }) {
-    if (!this.canUpdateMedia()) {
-      return this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.AUDIO, options);
+      if (receiveShare !== undefined) {
+        throw new Error(
+          'toggling receiveShare in a multistream meeting is not supported, to control receiving screen share call meeting.remoteMediaManager.setLayout() with appropriate layout'
+        );
+      }
     }
-    const {sendAudio, receiveAudio, stream} = options;
-    let track = MeetingUtil.getTrack(stream).audioTrack;
 
-    if (typeof sendAudio !== 'boolean' || typeof receiveAudio !== 'boolean') {
-      return Promise.reject(new ParameterError('Pass sendAudio and receiveAudio parameter'));
+    if (audioEnabled !== undefined) {
+      this.mediaProperties.mediaDirection.sendAudio = audioEnabled;
+      this.mediaProperties.mediaDirection.receiveAudio = audioEnabled;
+      this.audio.enable(this, audioEnabled);
     }
 
-    if (!this.mediaProperties.webrtcMediaConnection) {
-      return Promise.reject(new Error('media connection not established, call addMedia() first'));
+    if (videoEnabled !== undefined) {
+      this.mediaProperties.mediaDirection.sendVideo = videoEnabled;
+      this.mediaProperties.mediaDirection.receiveVideo = videoEnabled;
+      this.video.enable(this, videoEnabled);
     }
 
-    if (this.effects && this.effects.state) {
-      const bnrEnabled = this.effects.state.bnr.enabled;
+    if (receiveShare !== undefined) {
+      this.mediaProperties.mediaDirection.receiveShare = receiveShare;
+    }
 
-      if (
-        sendAudio &&
-        !this.isAudioMuted() &&
-        (bnrEnabled === BNR_STATUS.ENABLED || bnrEnabled === BNR_STATUS.SHOULD_ENABLE)
-      ) {
-        LoggerProxy.logger.info('Meeting:index#updateAudio. Calling WebRTC enable bnr method');
-        track = await this.internal_enableBNR(track);
-        LoggerProxy.logger.info('Meeting:index#updateAudio. WebRTC enable bnr request completed');
+    if (this.isMultistream) {
+      if (audioEnabled !== undefined) {
+        await this.mediaProperties.webrtcMediaConnection.enableMultistreamAudio(audioEnabled);
       }
+    } else {
+      await this.updateTranscodedMediaConnection();
     }
 
-    return MeetingUtil.validateOptions({sendAudio, localStream: stream})
-      .then(() =>
-        this.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions({
-          send: {audio: track},
-          receive: {
-            audio: options.receiveAudio,
-            video: this.mediaProperties.mediaDirection.receiveVideo,
-            screenShareVideo: this.mediaProperties.mediaDirection.receiveShare,
-            remoteQualityLevel: this.mediaProperties.remoteQualityLevel,
-          },
-        })
-      )
-      .then(() => {
-        this.setLocalAudioTrack(track);
-        // todo: maybe this.mediaProperties.mediaDirection could be removed? it's duplicating stuff from webrtcMediaConnection
-        this.mediaProperties.mediaDirection.sendAudio = sendAudio;
-        this.mediaProperties.mediaDirection.receiveAudio = receiveAudio;
-
-        // audio state could be undefined if you have not sent audio before
-        this.audio =
-          this.audio || createMuteState(AUDIO, this, this.mediaProperties.mediaDirection);
-      });
-  }
-
-  /**
-   * Update the main video track with new parameters
-   *
-   * NOTE: this method can only be used with transcoded meetings, for multistream meetings use publishTrack()
-   *
-   * @param {Object} options
-   * @param {boolean} options.sendVideo
-   * @param {boolean} options.receiveVideo
-   * @param {MediaStream} options.stream Stream that contains the video track to update
-   * @returns {Promise}
-   * @public
-   * @memberof Meeting
-   */
-  public updateVideo(options: {sendVideo: boolean; receiveVideo: boolean; stream: MediaStream}) {
-    if (!this.canUpdateMedia()) {
-      return this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.VIDEO, options);
-    }
-    const {sendVideo, receiveVideo, stream} = options;
-    const track = MeetingUtil.getTrack(stream).videoTrack;
-
-    if (typeof sendVideo !== 'boolean' || typeof receiveVideo !== 'boolean') {
-      return Promise.reject(new ParameterError('Pass sendVideo and receiveVideo parameter'));
-    }
-
-    if (!this.mediaProperties.webrtcMediaConnection) {
-      return Promise.reject(new Error('media connection not established, call addMedia() first'));
-    }
-
-    return MeetingUtil.validateOptions({sendVideo, localStream: stream})
-      .then(() =>
-        this.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions({
-          send: {video: track},
-          receive: {
-            audio: this.mediaProperties.mediaDirection.receiveAudio,
-            video: options.receiveVideo,
-            screenShareVideo: this.mediaProperties.mediaDirection.receiveShare,
-            remoteQualityLevel: this.mediaProperties.remoteQualityLevel,
-          },
-        })
-      )
-      .then(() => {
-        this.setLocalVideoTrack(track);
-        this.mediaProperties.mediaDirection.sendVideo = sendVideo;
-        this.mediaProperties.mediaDirection.receiveVideo = receiveVideo;
-
-        // video state could be undefined if you have not sent video before
-        this.video =
-          this.video || createMuteState(VIDEO, this, this.mediaProperties.mediaDirection);
-      });
-  }
-
-  /**
-   * Internal function when stopping a share stream, cleanup
-   * @param {boolean} sendShare
-   * @param {boolean} previousShareStatus
-   * @returns {Promise}
-   * @private
-   * @memberof Meeting
-   */
-  private checkForStopShare(sendShare: boolean, previousShareStatus: boolean) {
-    if (sendShare && !previousShareStatus) {
-      // When user starts sharing
-      return Promise.resolve(true);
-    }
-
-    if (!sendShare && previousShareStatus) {
-      // When user stops sharing
-      return this.releaseScreenShareFloor().then(() => Promise.resolve(false));
-    }
-
-    return Promise.resolve();
-  }
-
-  /**
-   * Update the share streams, can be used to start sharing
-   *
-   * NOTE: this method can only be used with transcoded meetings, for multistream meetings use publishTrack()
-   *
-   * @param {Object} options
-   * @param {boolean} options.sendShare
-   * @param {boolean} options.receiveShare
-   * @returns {Promise}
-   * @public
-   * @memberof Meeting
-   */
-  public updateShare(options: {
-    sendShare?: boolean;
-    receiveShare?: boolean;
-    stream?: any;
-    skipSignalingCheck?: boolean;
-  }) {
-    if (!options.skipSignalingCheck && !this.canUpdateMedia()) {
-      return this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.SHARE, options);
-    }
-    const {sendShare, receiveShare, stream} = options;
-    const track = MeetingUtil.getTrack(stream).videoTrack;
-
-    if (typeof sendShare !== 'boolean' || typeof receiveShare !== 'boolean') {
-      return Promise.reject(new ParameterError('Pass sendShare and receiveShare parameter'));
-    }
-
-    if (!this.mediaProperties.webrtcMediaConnection) {
-      return Promise.reject(new Error('media connection not established, call addMedia() first'));
-    }
-
-    const previousSendShareStatus = this.mediaProperties.mediaDirection.sendShare;
-
-    this.setLocalShareTrack(stream);
-
-    return MeetingUtil.validateOptions({sendShare, localShare: stream})
-      .then(() => this.checkForStopShare(sendShare, previousSendShareStatus))
-      .then((startShare) =>
-        this.mediaProperties.webrtcMediaConnection
-          .updateSendReceiveOptions({
-            send: {screenShareVideo: track},
-            receive: {
-              audio: this.mediaProperties.mediaDirection.receiveAudio,
-              video: this.mediaProperties.mediaDirection.receiveVideo,
-              screenShareVideo: options.receiveShare,
-              remoteQualityLevel: this.mediaProperties.remoteQualityLevel,
-            },
-          })
-          .then(() => {
-            if (startShare) {
-              return this.requestScreenShareFloor();
-            }
-
-            return Promise.resolve();
-          })
-      )
-      .then(() => {
-        this.mediaProperties.mediaDirection.sendShare = sendShare;
-        this.mediaProperties.mediaDirection.receiveShare = receiveShare;
-      })
-      .catch((error) => {
-        this.unsetLocalShareTrack();
-        throw error;
-      });
-  }
-
-  /**
-   * Do all the attach media pre set up before executing the actual attach
-   * @param {MediaStream} localStream
-   * @param {MediaStream} localShare
-   * @param {MediaDirection} mediaSettings
-   * @returns {undefined}
-   * @private
-   * @memberof Meeting
-   */
-  private preMedia(localStream: MediaStream, localShare: MediaStream, mediaSettings: any) {
-    // eslint-disable-next-line no-warning-comments
-    // TODO wire into default config. There's currently an issue with the stateless plugin or how we register
-    // @ts-ignore - config coming from registerPlugin
-    this.mediaProperties.setMediaDirection(Object.assign(this.config.mediaSettings, mediaSettings));
-    // add a setup a function move the create and setup media in future
-    // TODO: delete old audio and video if stale
-    this.audio = this.audio || createMuteState(AUDIO, this, this.mediaProperties.mediaDirection);
-    this.video = this.video || createMuteState(VIDEO, this, this.mediaProperties.mediaDirection);
-    // Validation is already done in addMedia so no need to check if the lenght is greater then 0
-    this.setLocalTracks(localStream);
-    this.setLocalShareTrack(localShare);
+    return undefined;
   }
 
   /**
@@ -5563,13 +5590,12 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   public leave(options: {resourceId?: string; reason?: any} = {} as any) {
+    const leaveReason = options.reason || MEETING_REMOVED_REASON.CLIENT_LEAVE_REQUEST;
     Metrics.postEvent({
       event: eventType.LEAVE,
       meeting: this,
-      data: {trigger: trigger.USER_INTERACTION, canProceed: false},
+      data: {trigger: trigger.USER_INTERACTION, canProceed: false, reason: leaveReason},
     });
-    const leaveReason = options.reason || MEETING_REMOVED_REASON.CLIENT_LEAVE_REQUEST;
-
     LoggerProxy.logger.log('Meeting:index#leave --> Leaving a meeting');
 
     return MeetingUtil.leaveMeeting(this, options)
@@ -5738,55 +5764,68 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   private requestScreenShareFloor() {
-    const content = this.locusInfo.mediaShares.find((element) => element.name === CONTENT);
+    if (!this.mediaProperties.shareTrack || !this.mediaProperties.mediaDirection.sendShare) {
+      LoggerProxy.logger.log(
+        `Meeting:index#requestScreenShareFloor --> NOT requesting floor, because we don't have the share track anymore (shareTrack=${
+          this.mediaProperties.shareTrack ? 'yes' : 'no'
+        }, sendShare=${this.mediaProperties.mediaDirection.sendShare})`
+      );
 
-    if (content && this.shareStatus !== SHARE_STATUS.LOCAL_SHARE_ACTIVE) {
-      Metrics.postEvent({event: eventType.SHARE_INITIATED, meeting: this});
+      return Promise.resolve({});
+    }
+    if (this.state === MEETING_STATE.STATES.JOINED) {
+      const content = this.locusInfo.mediaShares.find((element) => element.name === CONTENT);
+
+      if (content && this.shareStatus !== SHARE_STATUS.LOCAL_SHARE_ACTIVE) {
+        Metrics.postEvent({event: eventType.SHARE_INITIATED, meeting: this});
+
+        return this.meetingRequest
+          .changeMeetingFloor({
+            disposition: FLOOR_ACTION.GRANTED,
+            personUrl: this.locusInfo.self.url,
+            deviceUrl: this.deviceUrl,
+            uri: content.url,
+            resourceUrl: this.resourceUrl,
+            annotationInfo: this.annotationInfo,
+          })
+          .then(() => {
+            this.isSharing = true;
 
-      return this.meetingRequest
-        .changeMeetingFloor({
-          disposition: FLOOR_ACTION.GRANTED,
-          personUrl: this.locusInfo.self.url,
-          deviceUrl: this.deviceUrl,
-          uri: content.url,
-          resourceUrl: this.resourceUrl,
-        })
-        .then(() => {
-          this.isSharing = true;
+            return Promise.resolve();
+          })
+          .catch((error) => {
+            LoggerProxy.logger.error('Meeting:index#share --> Error ', error);
 
-          return Promise.resolve();
-        })
-        .catch((error) => {
-          LoggerProxy.logger.error('Meeting:index#share --> Error ', error);
+            Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_SHARE_FAILURE, {
+              correlation_id: this.correlationId,
+              locus_id: this.locusUrl.split('/').pop(),
+              reason: error.message,
+              stack: error.stack,
+            });
 
-          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_SHARE_FAILURE, {
-            correlation_id: this.correlationId,
-            locus_id: this.locusUrl.split('/').pop(),
-            reason: error.message,
-            stack: error.stack,
+            return Promise.reject(error);
           });
+      }
 
-          return Promise.reject(error);
-        });
+      return Promise.reject(new ParameterError('Cannot share without content.'));
     }
+    this.floorGrantPending = true;
 
-    return Promise.reject(new ParameterError('Cannot share without content.'));
+    return Promise.resolve({});
   }
 
   /**
-   * Stops the screen share
-   * @returns {Promise} see #updateShare
-   * @public
-   * @memberof Meeting
+   * Requests screen share floor if such request is pending.
+   * It should be called whenever meeting state changes to JOINED
+   *
+   * @returns {void}
    */
-  // Internal only, temporarily allows optional params
-  // eslint-disable-next-line valid-jsdoc
-  public stopShare(options = {}) {
-    return this.updateShare({
-      sendShare: false,
-      receiveShare: this.mediaProperties.mediaDirection.receiveShare,
-      ...options,
-    });
+  private requestScreenShareFloorIfPending() {
+    if (this.floorGrantPending && this.state === MEETING_STATE.STATES.JOINED) {
+      this.requestScreenShareFloor().then(() => {
+        this.floorGrantPending = false;
+      });
+    }
   }
 
   /**
@@ -5798,11 +5837,10 @@ export default class Meeting extends StatelessWebexPlugin {
   private releaseScreenShareFloor() {
     const content = this.locusInfo.mediaShares.find((element) => element.name === CONTENT);
 
-    if (content && this.mediaProperties.mediaDirection.sendShare) {
+    if (content) {
       Metrics.postEvent({event: eventType.SHARE_STOPPED, meeting: this});
-      Media.stopTracks(this.mediaProperties.shareTrack);
 
-      if (content.floor.beneficiary.id !== this.selfId) {
+      if (content.floor?.beneficiary.id !== this.selfId) {
         // remote participant started sharing and caused our sharing to stop, we don't want to send any floor action request in that case
         this.isSharing = false;
 
@@ -5834,7 +5872,10 @@ export default class Meeting extends StatelessWebexPlugin {
         });
     }
 
-    return Promise.reject(new ParameterError('Cannot stop share without content'));
+    // according to Locus there is no content, so we don't need to release the floor (it's probably already been released)
+    this.isSharing = false;
+
+    return Promise.resolve();
   }
 
   /**
@@ -5844,7 +5885,50 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   public startRecording() {
-    return MeetingUtil.startRecording(this.meetingRequest, this.locusUrl, this.locusInfo);
+    return this.recordingController.startRecording();
+  }
+
+  /**
+   * set the mute on entry flag for participants if you're the host
+   * @returns {Promise}
+   * @param {boolean} enabled
+   * @public
+   * @memberof Meeting
+   */
+  public setMuteOnEntry(enabled: boolean) {
+    return this.controlsOptionsManager.setMuteOnEntry(enabled);
+  }
+
+  /**
+   * set the disallow unmute flag for participants if you're the host
+   * @returns {Promise}
+   * @param {boolean} enabled
+   * @public
+   * @memberof Meeting
+   */
+  public setDisallowUnmute(enabled: boolean) {
+    return this.controlsOptionsManager.setDisallowUnmute(enabled);
+  }
+
+  /**
+   * set the mute all flag for participants if you're the host
+   * @returns {Promise}
+   * @param {boolean} mutedEnabled
+   * @param {boolean} disallowUnmuteEnabled
+   * @param {boolean} muteOnEntryEnabled
+   * @public
+   * @memberof Meeting
+   */
+  public setMuteAll(
+    mutedEnabled: boolean,
+    disallowUnmuteEnabled: boolean,
+    muteOnEntryEnabled: boolean
+  ) {
+    return this.controlsOptionsManager.setMuteAll(
+      mutedEnabled,
+      disallowUnmuteEnabled,
+      muteOnEntryEnabled
+    );
   }
 
   /**
@@ -5854,7 +5938,7 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   public stopRecording() {
-    return MeetingUtil.stopRecording(this.meetingRequest, this.locusUrl, this.locusInfo);
+    return this.recordingController.stopRecording();
   }
 
   /**
@@ -5864,7 +5948,7 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   public pauseRecording() {
-    return MeetingUtil.pauseRecording(this.meetingRequest, this.locusUrl, this.locusInfo);
+    return this.recordingController.pauseRecording();
   }
 
   /**
@@ -5874,7 +5958,7 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   public resumeRecording() {
-    return MeetingUtil.resumeRecording(this.meetingRequest, this.locusUrl, this.locusInfo);
+    return this.recordingController.resumeRecording();
   }
 
   /**
@@ -6048,11 +6132,6 @@ export default class Meeting extends StatelessWebexPlugin {
         main: layoutInfo.main,
         content: layoutInfo.content,
       })
-      .then((response) => {
-        if (response && response.body && response.body.locus) {
-          this.locusInfo.onFullLocus(response.body.locus);
-        }
-      })
       .catch((error) => {
         LoggerProxy.logger.error('Meeting:index#changeVideoLayout --> Error ', error);
 
@@ -6060,62 +6139,6 @@ export default class Meeting extends StatelessWebexPlugin {
       });
   }
 
-  /**
-   * Sets the quality of the local video stream
-   * @param {String} level {LOW|MEDIUM|HIGH}
-   * @returns {Promise<MediaStream>} localStream
-   */
-  setLocalVideoQuality(level: string) {
-    LoggerProxy.logger.log(`Meeting:index#setLocalVideoQuality --> Setting quality to ${level}`);
-
-    if (!VIDEO_RESOLUTIONS[level]) {
-      return this.rejectWithErrorLog(`Meeting:index#setLocalVideoQuality --> ${level} not defined`);
-    }
-
-    if (!this.mediaProperties.mediaDirection.sendVideo) {
-      return this.rejectWithErrorLog(
-        'Meeting:index#setLocalVideoQuality --> unable to change video quality, sendVideo is disabled'
-      );
-    }
-
-    // If level is already the same, don't do anything
-    if (level === this.mediaProperties.localQualityLevel) {
-      LoggerProxy.logger.warn(
-        `Meeting:index#setLocalQualityLevel --> Quality already set to ${level}`
-      );
-
-      return Promise.resolve();
-    }
-
-    // Set the quality level in properties
-    this.mediaProperties.setLocalQualityLevel(level);
-
-    const mediaDirection = {
-      sendAudio: this.mediaProperties.mediaDirection.sendAudio,
-      sendVideo: this.mediaProperties.mediaDirection.sendVideo,
-      sendShare: this.mediaProperties.mediaDirection.sendShare,
-    };
-
-    // When changing local video quality level
-    // Need to stop current track first as chrome doesn't support resolution upscaling(for eg. changing 480p to 720p)
-    // Without feeding it a new track
-    // open bug link: https://bugs.chromium.org/p/chromium/issues/detail?id=943469
-    if (isBrowser('chrome') && this.mediaProperties.videoTrack)
-      Media.stopTracks(this.mediaProperties.videoTrack);
-
-    return this.getMediaStreams(mediaDirection, VIDEO_RESOLUTIONS[level]).then(
-      async ([localStream]) => {
-        await this.updateVideo({
-          sendVideo: true,
-          receiveVideo: true,
-          stream: localStream,
-        });
-
-        return localStream;
-      }
-    );
-  }
-
   /**
    * Sets the quality level of the remote incoming media
    * @param {String} level {LOW|MEDIUM|HIGH}
@@ -6151,129 +6174,7 @@ export default class Meeting extends StatelessWebexPlugin {
     // Set the quality level in properties
     this.mediaProperties.setRemoteQualityLevel(level);
 
-    return this.updateMedia({mediaSettings: this.mediaProperties.mediaDirection});
-  }
-
-  /**
-   * This is deprecated, please use setLocalVideoQuality for setting local and setRemoteQualityLevel for remote
-   * @param {String} level {LOW|MEDIUM|HIGH}
-   * @returns {Promise}
-   * @deprecated After FHD support
-   */
-  setMeetingQuality(level: string) {
-    LoggerProxy.logger.log(`Meeting:index#setMeetingQuality --> Setting quality to ${level}`);
-
-    if (!QUALITY_LEVELS[level]) {
-      return this.rejectWithErrorLog(`Meeting:index#setMeetingQuality --> ${level} not defined`);
-    }
-
-    const previousLevel = {
-      local: this.mediaProperties.localQualityLevel,
-      remote: this.mediaProperties.remoteQualityLevel,
-    };
-
-    // If level is already the same, don't do anything
-    if (
-      level === this.mediaProperties.localQualityLevel &&
-      level === this.mediaProperties.remoteQualityLevel
-    ) {
-      LoggerProxy.logger.warn(
-        `Meeting:index#setMeetingQuality --> Quality already set to ${level}`
-      );
-
-      return Promise.resolve();
-    }
-
-    // Determine the direction of our current media
-    const {receiveAudio, receiveVideo, sendVideo} = this.mediaProperties.mediaDirection;
-
-    return (sendVideo ? this.setLocalVideoQuality(level) : Promise.resolve())
-      .then(() =>
-        receiveAudio || receiveVideo ? this.setRemoteQualityLevel(level) : Promise.resolve()
-      )
-      .catch((error) => {
-        // From troubleshooting it seems that the stream itself doesn't change the max-fs if the peer connection isn't stable
-        this.mediaProperties.setLocalQualityLevel(previousLevel.local);
-        this.mediaProperties.setRemoteQualityLevel(previousLevel.remote);
-
-        LoggerProxy.logger.error(`Meeting:index#setMeetingQuality --> ${error.message}`);
-
-        Metrics.sendBehavioralMetric(
-          BEHAVIORAL_METRICS.SET_MEETING_QUALITY_FAILURE,
-          {
-            correlation_id: this.correlationId,
-            locus_id: this.locusUrl.split('/').pop(),
-            reason: error.message,
-            stack: error.stack,
-          },
-          {
-            type: error.name,
-          }
-        );
-
-        return Promise.reject(error);
-      });
-  }
-
-  /**
-   *
-   * NOTE: this method can only be used with transcoded meetings, for multistream use publishTrack()
-   *
-   * @param {Object} options parameter
-   * @param {Boolean} options.sendAudio send audio from the display share
-   * @param {Boolean} options.sendShare send video from the display share
-   * @param {Object} options.sharePreferences
-   * @param {MediaTrackConstraints} options.sharePreferences.shareConstraints constraints to apply to video
-   *   @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints}
-   * @param {Boolean} options.sharePreferences.highFrameRate if shareConstraints isn't provided, set default values based off of this boolean
-   * @returns {Promise}
-   */
-  shareScreen(
-    options: {
-      sendAudio: boolean;
-      sendShare: boolean;
-      sharePreferences: {shareConstraints: MediaTrackConstraints};
-    } = {} as any
-  ) {
-    LoggerProxy.logger.log('Meeting:index#shareScreen --> Getting local share');
-
-    const shareConstraints = {
-      sendShare: true,
-      sendAudio: false,
-      ...options,
-    };
-
-    // @ts-ignore - config coming from registerPlugin
-    return Media.getDisplayMedia(shareConstraints, this.config)
-      .then((shareStream) =>
-        this.updateShare({
-          sendShare: true,
-          receiveShare: this.mediaProperties.mediaDirection.receiveShare,
-          stream: shareStream,
-        })
-      )
-      .catch((error) => {
-        // Whenever there is a failure when trying to access a user's display
-        // report it as an Behavioral metric
-        // This gives visibility into common errors and can help
-        // with further troubleshooting
-
-        // This metrics will get erros for getDisplayMedia and share errors for now
-        // TODO: The getDisplayMedia errors need to be moved inside `media.getDisplayMedia`
-        const metricName = BEHAVIORAL_METRICS.GET_DISPLAY_MEDIA_FAILURE;
-        const data = {
-          correlation_id: this.correlationId,
-          locus_id: this.locusUrl.split('/').pop(),
-          reason: error.message,
-          stack: error.stack,
-        };
-        const metadata = {
-          type: error.name,
-        };
-
-        Metrics.sendBehavioralMetric(metricName, data, metadata);
-        throw new MediaError('Unable to retrieve display media stream', error);
-      });
+    return this.updateTranscodedMediaConnection();
   }
 
   /**
@@ -6283,20 +6184,18 @@ export default class Meeting extends StatelessWebexPlugin {
    * @param {MediaStream} localShare
    * @returns {undefined}
    */
-  private handleShareTrackEnded(localShare: MediaStream) {
+  private handleShareTrackEnded = async () => {
     if (this.wirelessShare) {
       this.leave({reason: MEETING_REMOVED_REASON.USER_ENDED_SHARE_STREAMS});
     } else {
-      // Skip checking for a stable peerConnection
-      // to allow immediately stopping screenshare
-      this.stopShare({
-        skipSignalingCheck: true,
-      }).catch((error) => {
+      try {
+        await this.unpublishTracks([this.mediaProperties.shareTrack]); // todo: screen share audio (SPARK-399690)
+      } catch (error) {
         LoggerProxy.logger.log(
           'Meeting:index#handleShareTrackEnded --> Error stopping share: ',
           error
         );
-      });
+      }
     }
 
     Trigger.trigger(
@@ -6307,11 +6206,10 @@ export default class Meeting extends StatelessWebexPlugin {
       },
       EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
       {
-        type: EVENT_TYPES.LOCAL_SHARE,
-        stream: localShare,
+        reason: SHARE_STOPPED_REASON.TRACK_ENDED,
       }
     );
-  }
+  };
 
   /**
    * Emits the 'network:quality' event
@@ -6341,14 +6239,16 @@ export default class Meeting extends StatelessWebexPlugin {
 
   /**
    * Handle logging the media
-   * @param {Object} audioTrack The audio track
-   * @param {Object} videoTrack The video track
+   * @param {Object} mediaProperties
    * @private
    * @returns {undefined}
    */
-  private handleMediaLogging({audioTrack, videoTrack}: any) {
-    MeetingUtil.handleVideoLogging(videoTrack);
-    MeetingUtil.handleAudioLogging(audioTrack);
+  private handleMediaLogging(mediaProperties: {
+    audioTrack?: LocalMicrophoneTrack;
+    videoTrack?: LocalCameraTrack;
+  }) {
+    MeetingUtil.handleVideoLogging(mediaProperties.videoTrack);
+    MeetingUtil.handleAudioLogging(mediaProperties.audioTrack);
   }
 
   /**
@@ -6437,7 +6337,7 @@ export default class Meeting extends StatelessWebexPlugin {
     const end = this.endLocalSDPGenRemoteSDPRecvDelay;
 
     if (start && end) {
-      const calculatedDelay = end - start;
+      const calculatedDelay = Math.round(end - start);
 
       return calculatedDelay > METRICS_JOIN_TIMES_MAX_DURATION ? undefined : calculatedDelay;
     }
@@ -6449,26 +6349,26 @@ export default class Meeting extends StatelessWebexPlugin {
    *
    * @returns {undefined}
    */
-  setStartCallInitiateJoinReq() {
-    this.startCallInitiateJoinReq = performance.now();
-    this.endCallInitiateJoinReq = undefined;
+  setStartCallInitJoinReq() {
+    this.startCallInitJoinReq = performance.now();
+    this.endCallInitJoinReq = undefined;
   }
 
   /**
    *
    * @returns {undefined}
    */
-  setEndCallInitiateJoinReq() {
-    this.endCallInitiateJoinReq = performance.now();
+  setEndCallInitJoinReq() {
+    this.endCallInitJoinReq = performance.now();
   }
 
   /**
    *
    * @returns {string} duration between call initiate and sending join request to locus
    */
-  getCallInitiateJoinReq() {
-    const start = this.startCallInitiateJoinReq;
-    const end = this.endCallInitiateJoinReq;
+  getCallInitJoinReq() {
+    const start = this.startCallInitJoinReq;
+    const end = this.endCallInitJoinReq;
 
     if (start && end) {
       const calculatedDelay = end - start;
@@ -6505,7 +6405,7 @@ export default class Meeting extends StatelessWebexPlugin {
     const end = this.endJoinReqResp;
 
     if (start && end) {
-      const calculatedDelay = end - start;
+      const calculatedDelay = Math.round(end - start);
 
       return calculatedDelay > METRICS_JOIN_TIMES_MAX_DURATION ? undefined : calculatedDelay;
     }
@@ -6518,10 +6418,45 @@ export default class Meeting extends StatelessWebexPlugin {
    * @returns {string} duration between call initiate and successful locus join (even if it is in lobby)
    */
   getTotalJmt() {
-    const start = this.startCallInitiateJoinReq;
+    const start = this.startCallInitJoinReq;
     const end = this.endJoinReqResp;
 
-    return start && end ? end - start : undefined;
+    return start && end ? Math.round(end - start) : undefined;
+  }
+
+  /**
+   *
+   * @returns {string} one of 'attendee','host','cohost', returns the user type of the current user
+   */
+  getCurUserType() {
+    const {roles} = this;
+    if (roles) {
+      if (roles.includes(SELF_ROLES.MODERATOR)) {
+        return 'host';
+      }
+      if (roles.includes(SELF_ROLES.COHOST)) {
+        return 'cohost';
+      }
+      if (roles.includes(SELF_ROLES.ATTENDEE)) {
+        return 'attendee';
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   *
+   * @returns {string} one of 'login-ci','unverified-guest', returns the login type of the current user
+   */
+  getCurLoginType() {
+    // @ts-ignore
+    if (this.webex.canAuthorize) {
+      // @ts-ignore
+      return this.webex.credentials.isUnverifiedGuest ? 'unverified-guest' : 'login-ci';
+    }
+
+    return null;
   }
 
   /**
@@ -6611,121 +6546,6 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   };
 
-  /**
-   * Internal API to return status of BNR
-   * @returns {Boolean}
-   * @public
-   * @memberof Meeting
-   */
-  public isBnrEnabled() {
-    return this.effects && this.effects.isBnrEnabled();
-  }
-
-  /**
-   * Internal API to obtain BNR enabled MediaStream
-   * @returns {Promise<MediaStreamTrack>}
-   * @private
-   * @param {MedaiStreamTrack} audioTrack from updateAudio
-   * @memberof Meeting
-   */
-  private async internal_enableBNR(audioTrack: any) {
-    try {
-      LoggerProxy.logger.info('Meeting:index#internal_enableBNR. Internal enable BNR called');
-      const bnrAudioTrack = await WebRTCMedia.Effects.BNR.enableBNR(audioTrack);
-
-      LoggerProxy.logger.info(
-        'Meeting:index#internal_enableBNR. BNR enabled track obtained from WebRTC & returned as stream'
-      );
-
-      return bnrAudioTrack;
-    } catch (error) {
-      LoggerProxy.logger.error('Meeting:index#internal_enableBNR.', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Enable the audio track with BNR for a meeting
-   * @returns {Promise} resolves the data from enable bnr or rejects if there is no audio or audio is muted
-   * @public
-   * @memberof Meeting
-   */
-  public enableBNR() {
-    if (
-      typeof this.mediaProperties === 'undefined' ||
-      typeof this.mediaProperties.audioTrack === 'undefined'
-    ) {
-      return Promise.reject(new Error("Meeting doesn't have an audioTrack attached"));
-    }
-
-    if (this.isAudioMuted()) {
-      return Promise.reject(new Error('Cannot enable BNR while meeting is muted'));
-    }
-
-    this.effects = this.effects || createEffectsState('BNR');
-
-    const LOG_HEADER = 'Meeting:index#enableBNR -->';
-
-    return logRequest(
-      this.effects
-        .handleClientRequest(true, this)
-        .then((res) => {
-          LoggerProxy.logger.info('Meeting:index#enableBNR. Enable bnr completed');
-
-          return res;
-        })
-        .catch((error) => {
-          throw error;
-        }),
-      {
-        header: `${LOG_HEADER} enable bnr`,
-        success: `${LOG_HEADER} enable bnr success`,
-        failure: `${LOG_HEADER} enable bnr failure, `,
-      }
-    );
-  }
-
-  /**
-   * Disable the BNR for an audio track
-   * @returns {Promise} resolves the data from disable bnr or rejects if there is no audio set
-   * @public
-   * @memberof Meeting
-   */
-  public disableBNR() {
-    if (
-      typeof this.mediaProperties === 'undefined' ||
-      typeof this.mediaProperties.audioTrack === 'undefined'
-    ) {
-      return Promise.reject(new Error("Meeting doesn't have an audioTrack attached"));
-    }
-
-    if (!this.isBnrEnabled()) {
-      return Promise.reject(new Error('Can not disable as BNR is not enabled'));
-    }
-
-    this.effects = this.effects || createEffectsState('BNR');
-
-    const LOG_HEADER = 'Meeting:index#disableBNR -->';
-
-    return logRequest(
-      this.effects
-        .handleClientRequest(false, this)
-        .then((res) => {
-          LoggerProxy.logger.info('Meeting:index#disableBNR. Disable bnr completed');
-
-          return res;
-        })
-        .catch((error) => {
-          throw error;
-        }),
-      {
-        header: `${LOG_HEADER} disable bnr`,
-        success: `${LOG_HEADER} disable bnr success`,
-        failure: `${LOG_HEADER} disable bnr failure, `,
-      }
-    );
-  }
-
   /**
    * starts keepAlives being sent
    * @returns {void}
@@ -6791,13 +6611,13 @@ export default class Meeting extends StatelessWebexPlugin {
   /**
    * Send a reaction inside the meeting.
    *
-   * @param {ReactionType} reactionType - type of reaction to be sent. Example: "thumbs_up"
+   * @param {ReactionServerType} reactionType - type of reaction to be sent. Example: "thumbs_up"
    * @param {SkinToneType} skinToneType - skin tone for the reaction. Example: "medium_dark"
    * @returns {Promise}
    * @public
    * @memberof Meeting
    */
-  public sendReaction(reactionType: ReactionType, skinToneType?: SkinToneType) {
+  public sendReaction(reactionType: ReactionServerType, skinToneType?: SkinToneType) {
     const reactionChannelUrl = this.locusInfo?.controls?.reactions?.reactionChannelUrl as string;
     const participantId = this.members.selfId;
 
@@ -6840,4 +6660,222 @@ export default class Meeting extends StatelessWebexPlugin {
       requestingParticipantId: this.members.selfId,
     });
   }
+
+  /**
+   * Throws if we don't have a media connection created
+   *
+   * @returns {void}
+   */
+  private checkMediaConnection() {
+    if (this.mediaProperties?.webrtcMediaConnection) {
+      return;
+    }
+    throw new NoMediaEstablishedYetError();
+  }
+
+  /**
+   * Method to enable or disable the 'Music mode' effect on audio track
+   *
+   * @param {boolean} shouldEnableMusicMode
+   * @returns {Promise}
+   */
+  async enableMusicMode(shouldEnableMusicMode: boolean) {
+    this.checkMediaConnection();
+
+    if (!this.isMultistream) {
+      throw new Error('enableMusicMode() only supported with multistream');
+    }
+
+    if (shouldEnableMusicMode) {
+      await this.mediaProperties.webrtcMediaConnection.setCodecParameters(MediaType.AudioMain, {
+        maxaveragebitrate: '64000',
+        maxplaybackrate: '48000',
+      });
+    } else {
+      await this.mediaProperties.webrtcMediaConnection.deleteCodecParameters(MediaType.AudioMain, [
+        'maxaveragebitrate',
+        'maxplaybackrate',
+      ]);
+    }
+  }
+
+  /** Updates the tracks being sent on the transcoded media connection
+   *
+   * @returns {Promise<void>}
+   */
+  private updateTranscodedMediaConnection(): Promise<void> {
+    const LOG_HEADER = 'Meeting:index#updateTranscodedMediaConnection -->';
+
+    LoggerProxy.logger.info(`${LOG_HEADER} starting`);
+
+    if (!this.canUpdateMedia()) {
+      return this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.TRANSCODED_MEDIA_CONNECTION);
+    }
+
+    return this.mediaProperties.webrtcMediaConnection
+      .update({
+        localTracks: {
+          audio: this.mediaProperties.audioTrack?.underlyingTrack || null,
+          video: this.mediaProperties.videoTrack?.underlyingTrack || null,
+          screenShareVideo: this.mediaProperties.shareTrack?.underlyingTrack || null,
+        },
+        direction: {
+          audio: Media.getDirection(
+            true,
+            this.mediaProperties.mediaDirection.receiveAudio,
+            this.mediaProperties.mediaDirection.sendAudio
+          ),
+          video: Media.getDirection(
+            true,
+            this.mediaProperties.mediaDirection.receiveVideo,
+            this.mediaProperties.mediaDirection.sendVideo
+          ),
+          screenShareVideo: Media.getDirection(
+            false,
+            this.mediaProperties.mediaDirection.receiveShare,
+            this.mediaProperties.mediaDirection.sendShare
+          ),
+        },
+        remoteQualityLevel: this.mediaProperties.remoteQualityLevel,
+      })
+      .then(() => {
+        LoggerProxy.logger.info(`${LOG_HEADER} done`);
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error(`${LOG_HEADER} Error: `, error);
+
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.UPDATE_MEDIA_FAILURE, {
+          correlation_id: this.correlationId,
+          locus_id: this.locusUrl.split('/').pop(),
+          reason: error.message,
+          stack: error.stack,
+        });
+
+        throw error;
+      });
+  }
+
+  /**
+   * Publishes a track.
+   *
+   * @param {LocalTrack} track to publish
+   * @returns {Promise}
+   */
+  private async publishTrack(track?: LocalTrack) {
+    if (!track) {
+      return;
+    }
+
+    if (this.mediaProperties.webrtcMediaConnection) {
+      if (this.isMultistream) {
+        await this.mediaProperties.webrtcMediaConnection.publishTrack(track);
+      } else {
+        track.setPublished(true); // for multistream, this call is done by WCME
+      }
+    }
+  }
+
+  /**
+   * Un-publishes a track.
+   *
+   * @param {LocalTrack} track to unpublish
+   * @returns {Promise}
+   */
+  private async unpublishTrack(track?: LocalTrack) {
+    if (!track) {
+      return;
+    }
+
+    if (this.isMultistream && this.mediaProperties.webrtcMediaConnection) {
+      await this.mediaProperties.webrtcMediaConnection.unpublishTrack(track);
+    } else {
+      track.setPublished(false); // for multistream, this call is done by WCME
+    }
+  }
+
+  /**
+   * Publishes specified local tracks in the meeting
+   *
+   * @param {Object} tracks
+   * @returns {Promise}
+   */
+  async publishTracks(tracks: LocalTracks): Promise<void> {
+    this.checkMediaConnection();
+
+    this.annotationInfo = tracks.annotationInfo;
+
+    if (
+      !tracks.microphone &&
+      !tracks.camera &&
+      !tracks.screenShare?.audio &&
+      !tracks.screenShare?.video
+    ) {
+      // nothing to do
+      return;
+    }
+
+    let floorRequestNeeded = false;
+
+    if (tracks.screenShare?.video) {
+      await this.setLocalShareTrack(tracks.screenShare?.video);
+
+      floorRequestNeeded = true;
+    }
+
+    if (tracks.microphone) {
+      await this.setLocalAudioTrack(tracks.microphone);
+    }
+
+    if (tracks.camera) {
+      await this.setLocalVideoTrack(tracks.camera);
+    }
+
+    if (!this.isMultistream) {
+      await this.updateTranscodedMediaConnection();
+    }
+
+    if (floorRequestNeeded) {
+      // we're sending the http request to Locus to request the screen share floor
+      // only after the SDP update, because that's how it's always been done for transcoded meetings
+      // and also if sharing from the start, we need confluence to have been created
+      await this.enqueueMediaUpdate(MEDIA_UPDATE_TYPE.SHARE_FLOOR_REQUEST);
+    }
+  }
+
+  /**
+   * Un-publishes specified local tracks in the meeting
+   *
+   * @param {Array<MediaStreamTrack>} tracks
+   * @returns {Promise}
+   */
+  async unpublishTracks(tracks: LocalTrack[]): Promise<void> {
+    this.checkMediaConnection();
+
+    const promises = [];
+
+    for (const track of tracks.filter((t) => !!t)) {
+      if (track === this.mediaProperties.shareTrack) {
+        try {
+          this.releaseScreenShareFloor(); // we ignore the returned promise here on purpose
+        } catch (e) {
+          // nothing to do here, error is logged already inside releaseScreenShareFloor()
+        }
+        promises.push(this.setLocalShareTrack(undefined));
+      }
+
+      if (track === this.mediaProperties.audioTrack) {
+        promises.push(this.setLocalAudioTrack(undefined));
+      }
+
+      if (track === this.mediaProperties.videoTrack) {
+        promises.push(this.setLocalVideoTrack(undefined));
+      }
+    }
+
+    if (!this.isMultistream) {
+      promises.push(this.updateTranscodedMediaConnection());
+    }
+
+    await Promise.all(promises);
+  }
 }