@webex/plugin-meetings 3.0.0-beta.15 → 3.0.0-beta.151

package/test/unit/spec/meeting/index.js

@@ -2,14 +2,16 @@
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
 import 'jsdom-global/register';
-import {cloneDeep, isEqual} from 'lodash';
+import {cloneDeep, forEach, isEqual} from 'lodash';
 import sinon from 'sinon';
+import * as internalMediaModule from '@webex/internal-media-core';
 import StateMachine from 'javascript-state-machine';
 import uuid from 'uuid';
 import {assert} from '@webex/test-helper-chai';
-import {Credentials} from '@webex/webex-core';
+import {Credentials, Token, WebexPlugin} from '@webex/webex-core';
 import Support from '@webex/internal-plugin-support';
 import MockWebex from '@webex/test-helper-mock-webex';
+import StaticConfig from '@webex/plugin-meetings/src/common/config';
 import {
   FLOOR_ACTION,
   SHARE_STATUS,
@@ -19,23 +21,42 @@ import {
   EVENT_TRIGGERS,
   _SIP_URI_,
   _MEETING_ID_,
+  MEETING_REMOVED_REASON,
   LOCUSINFO,
   PC_BAIL_TIMEOUT,
+  DISPLAY_HINTS,
 } from '@webex/plugin-meetings/src/constants';
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import * as InternalMediaCoreModule from '@webex/internal-media-core';
+import {
+  ConnectionState,
+  Event,
+  Errors,
+  ErrorType,
+  RemoteTrackType,
+  MediaType,
+} from '@webex/internal-media-core';
+import {
+  LocalTrackEvents,
+} from '@webex/media-helpers';
 import * as StatsAnalyzerModule from '@webex/plugin-meetings/src/statsAnalyzer';
+import * as MuteStateModule from '@webex/plugin-meetings/src/meeting/muteState';
 import EventsScope from '@webex/plugin-meetings/src/common/events/events-scope';
 import Meetings, {CONSTANTS} from '@webex/plugin-meetings';
 import Meeting from '@webex/plugin-meetings/src/meeting';
 import Members from '@webex/plugin-meetings/src/members';
+import * as MembersImport from '@webex/plugin-meetings/src/members';
 import Roap from '@webex/plugin-meetings/src/roap';
+import RoapRequest from '@webex/plugin-meetings/src/roap/request';
 import MeetingRequest from '@webex/plugin-meetings/src/meeting/request';
+import * as MeetingRequestImport from '@webex/plugin-meetings/src/meeting/request';
 import LocusInfo from '@webex/plugin-meetings/src/locus-info';
 import MediaProperties from '@webex/plugin-meetings/src/media/properties';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import Media from '@webex/plugin-meetings/src/media/index';
 import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
 import MediaUtil from '@webex/plugin-meetings/src/media/util';
+import RecordingUtil from '@webex/plugin-meetings/src/recording-controller/util';
+import ControlsOptionsUtil from '@webex/plugin-meetings/src/controls-options-manager/util';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
 import TriggerProxy from '@webex/plugin-meetings/src/common/events/trigger-proxy';
@@ -43,8 +64,13 @@ import BrowserDetection from '@webex/plugin-meetings/src/common/browser-detectio
 import Metrics from '@webex/plugin-meetings/src/metrics';
 import {trigger, eventType} from '@webex/plugin-meetings/src/metrics/config';
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
-import {IceGatheringFailed} from '@webex/plugin-meetings/src/common/errors/webex-errors';
+import {MediaRequestManager} from '@webex/plugin-meetings/src/multistream/mediaRequestManager';
+import * as ReceiveSlotManagerModule from '@webex/plugin-meetings/src/multistream/receiveSlotManager';
 
+import LLM from '@webex/internal-plugin-llm';
+import Mercury from '@webex/internal-plugin-mercury';
+import Breakouts from '@webex/plugin-meetings/src/breakouts';
+import {REACTION_RELAY_TYPES} from '../../../../src/reactions/constants';
 import locus from '../fixture/locus';
 import {
   UserNotJoinedError,
@@ -56,15 +82,18 @@ import WebExMeetingsErrors from '../../../../src/common/errors/webex-meetings-er
 import ParameterError from '../../../../src/common/errors/parameter';
 import PasswordError from '../../../../src/common/errors/password-error';
 import CaptchaError from '../../../../src/common/errors/captcha-error';
+import PermissionError from '../../../../src/common/errors/permission';
 import IntentToJoinError from '../../../../src/common/errors/intent-to-join';
 import DefaultSDKConfig from '../../../../src/config';
 import testUtils from '../../../utils/testUtils';
 import {
   MeetingInfoV2CaptchaError,
   MeetingInfoV2PasswordError,
+  MeetingInfoV2PolicyError,
 } from '../../../../src/meeting-info/meeting-info-v2';
+import {ANNOTATION_POLICY} from "../../../../src/annotation/constants";
 
-const {getBrowserName} = BrowserDetection();
+const {getBrowserName, getOSVersion} = BrowserDetection();
 
 // Non-stubbed function
 const {getDisplayMedia} = Media;
@@ -127,6 +156,15 @@ describe('plugin-meetings', () => {
       },
     });
 
+    Object.defineProperty(global.window.navigator, 'permissions', {
+      writable: true,
+      value: {
+        query: sinon.stub().callsFake(async (arg) => {
+          return {state: 'granted', name: arg.name};
+        }),
+      },
+    });
+
     Object.defineProperty(global.window, 'MediaStream', {
       writable: true,
       value: MediaStream,
@@ -148,6 +186,8 @@ describe('plugin-meetings', () => {
   let test3;
   let test4;
   let testDestination;
+  let membersSpy;
+  let meetingRequestSpy;
 
   beforeEach(() => {
     webex = new MockWebex({
@@ -155,10 +195,12 @@ describe('plugin-meetings', () => {
         meetings: Meetings,
         credentials: Credentials,
         support: Support,
+        llm: LLM,
+        mercury: Mercury,
       },
       config: {
         credentials: {
-          client_id: 'mock-client-id',
+          client_id: 'mock-client-id'
         },
         meetings: {
           reconnection: {
@@ -168,6 +210,7 @@ describe('plugin-meetings', () => {
           metrics: {},
           stats: {},
           experimental: {enableUnifiedMeetings: true},
+          degradationPreferences: { maxMacroblocksLimit: 8192 },
         },
         metrics: {
           type: ['behavioral'],
@@ -179,11 +222,18 @@ describe('plugin-meetings', () => {
     webex.credentials.getOrgId = sinon.stub().returns('fake-org-id');
     webex.internal.metrics.submitClientMetrics = sinon.stub().returns(Promise.resolve());
     webex.meetings.uploadLogs = sinon.stub().returns(Promise.resolve());
+    webex.internal.llm.on = sinon.stub();
+    membersSpy = sinon.spy(MembersImport, 'default');
+    meetingRequestSpy = sinon.spy(MeetingRequestImport, 'default');
 
     TriggerProxy.trigger = sinon.stub().returns(true);
     Metrics.postEvent = sinon.stub();
     Metrics.initialSetup(null, webex);
-    MediaUtil.createMediaStream = sinon.stub().returns(true);
+    MediaUtil.createMediaStream = sinon.stub().callsFake((tracks) => {
+      return {
+        getTracks: () => tracks,
+      };
+    });
 
     uuid1 = uuid.v4();
     uuid2 = uuid.v4();
@@ -228,6 +278,16 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.deviceUrl, uuid3);
           assert.deepEqual(meeting.meetingInfo, {});
           assert.instanceOf(meeting.members, Members);
+          assert.calledOnceWithExactly(
+            membersSpy,
+            {
+              locusUrl: meeting.locusUrl,
+              receiveSlotManager: meeting.receiveSlotManager,
+              mediaRequestManagers: meeting.mediaRequestManagers,
+              meeting,
+            },
+            {parent: meeting.webex}
+          );
           assert.instanceOf(meeting.roap, Roap);
           assert.instanceOf(meeting.reconnectionManager, ReconnectionManager);
           assert.isNull(meeting.audio);
@@ -242,6 +302,13 @@ describe('plugin-meetings', () => {
           assert.isNull(meeting.hostId);
           assert.isNull(meeting.policy);
           assert.instanceOf(meeting.meetingRequest, MeetingRequest);
+          assert.calledOnceWithExactly(
+            meetingRequestSpy,
+            {
+              meeting,
+            },
+            {parent: meeting.webex}
+          );
           assert.instanceOf(meeting.locusInfo, LocusInfo);
           assert.equal(meeting.fetchMeetingInfoTimeoutId, undefined);
           assert.instanceOf(meeting.mediaProperties, MediaProperties);
@@ -250,6 +317,98 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.meetingInfoFailureReason, undefined);
           assert.equal(meeting.destination, testDestination);
           assert.equal(meeting.destinationType, _MEETING_ID_);
+          assert.instanceOf(meeting.breakouts, Breakouts);
+        });
+        it('creates MediaRequestManager instances', () => {
+          assert.instanceOf(meeting.mediaRequestManagers.audio, MediaRequestManager);
+          assert.instanceOf(meeting.mediaRequestManagers.video, MediaRequestManager);
+          assert.instanceOf(meeting.mediaRequestManagers.screenShareAudio, MediaRequestManager);
+          assert.instanceOf(meeting.mediaRequestManagers.screenShareVideo, MediaRequestManager);
+        });
+
+        describe('creates ReceiveSlot manager instance', () => {
+          let mockReceiveSlotManagerCtor;
+          let providedCreateSlotCallback;
+          let providedFindMemberIdByCsiCallback;
+
+          beforeEach(() => {
+            mockReceiveSlotManagerCtor = sinon
+              .stub(ReceiveSlotManagerModule, 'ReceiveSlotManager')
+              .callsFake((createSlotCallback, findMemberIdByCsiCallback) => {
+                providedCreateSlotCallback = createSlotCallback;
+                providedFindMemberIdByCsiCallback = findMemberIdByCsiCallback;
+
+                return {updateMemberIds: sinon.stub()};
+              });
+
+            meeting = new Meeting(
+              {
+                userId: uuid1,
+                resource: uuid2,
+                deviceUrl: uuid3,
+                locus: {url: url1},
+                destination: testDestination,
+                destinationType: _MEETING_ID_,
+              },
+              {
+                parent: webex,
+              }
+            );
+
+            meeting.mediaProperties.webrtcMediaConnection = {createReceiveSlot: sinon.stub()};
+          });
+
+          it('calls ReceiveSlotManager constructor', () => {
+            assert.calledOnce(mockReceiveSlotManagerCtor);
+            assert.isDefined(providedCreateSlotCallback);
+            assert.isDefined(providedFindMemberIdByCsiCallback);
+          });
+
+          it('calls createReceiveSlot on the webrtc media connection in the createSlotCallback', async () => {
+            assert.isDefined(providedCreateSlotCallback);
+
+            await providedCreateSlotCallback(MediaType.VideoMain);
+
+            assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+            assert.calledWith(
+              meeting.mediaProperties.webrtcMediaConnection.createReceiveSlot,
+              MediaType.VideoMain
+            );
+          });
+
+          it('rejects createSlotCallback if there is no webrtc media connection', () => {
+            assert.isDefined(providedCreateSlotCallback);
+
+            meeting.mediaProperties.webrtcMediaConnection.createReceiveSlot.rejects({});
+
+            assert.isRejected(providedCreateSlotCallback(MediaType.VideoMain));
+          });
+
+          it('calls findMemberByCsi in findMemberIdByCsiCallback and returns the right value', () => {
+            assert.isDefined(providedFindMemberIdByCsiCallback);
+
+            const fakeMember = {id: 'aaa-bbb'};
+
+            sinon.stub(meeting.members, 'findMemberByCsi').returns(fakeMember);
+
+            const memberId = providedFindMemberIdByCsiCallback(123);
+
+            assert.calledOnce(meeting.members.findMemberByCsi);
+            assert.calledWith(meeting.members.findMemberByCsi, 123);
+            assert.equal(memberId, fakeMember.id);
+          });
+
+          it('returns undefined if findMemberByCsi does not find the member', () => {
+            assert.isDefined(providedFindMemberIdByCsiCallback);
+
+            sinon.stub(meeting.members, 'findMemberByCsi').returns(undefined);
+
+            const memberId = providedFindMemberIdByCsiCallback(123);
+
+            assert.calledOnce(meeting.members.findMemberByCsi);
+            assert.calledWith(meeting.members.findMemberByCsi, 123);
+            assert.equal(memberId, undefined);
+          });
         });
       });
       describe('#invite', () => {
@@ -299,6 +458,21 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.members.admitMembers);
           assert.calledWith(meeting.members.admitMembers, [uuid1]);
         });
+        it('should call from a breakout session if caller is in a breakout session', async () => {
+          const locusUrls = {
+            authorizingLocusUrl: 'authorizingLocusUrl',
+            mainLocusUrl: 'mainLocusUrl',
+          };
+          await meeting.admit([uuid1], locusUrls);
+          assert.calledOnce(meeting.members.admitMembers);
+          assert.calledWith(meeting.members.admitMembers, [uuid1], locusUrls);
+
+          meeting.breakouts.set('locusUrl', 'authorizingLocusUrl');
+          meeting.breakouts.set('mainLocusUrl', 'mainLocusUrl');
+          await meeting.admit([uuid1]);
+          const args = meeting.members.admitMembers.getCall(1).args;
+          assert.deepEqual(args, [[uuid1], locusUrls]);
+        });
       });
       describe('#getMembers', () => {
         it('should have #getMembers', () => {
@@ -310,325 +484,7 @@ describe('plugin-meetings', () => {
           assert.instanceOf(members, Members);
         });
       });
-      describe('#isAudioMuted', () => {
-        it('should have #isAudioMuted', () => {
-          assert.exists(meeting.invite);
-        });
-        it('should get the audio muted status and return as a boolean', () => {
-          const muted = meeting.isAudioMuted();
-
-          assert.isNotOk(muted);
-        });
-      });
-      describe('#isAudioSelf', () => {
-        it('should have #isAudioSelf', () => {
-          assert.exists(meeting.invite);
-        });
-        it('should get the audio self status and return as a boolean', () => {
-          const self = meeting.isAudioSelf();
-
-          assert.isNotOk(self);
-        });
-      });
-      describe('#isVideoMuted', () => {
-        it('should have #isVideoMuted', () => {
-          assert.exists(meeting.isVideoMuted);
-        });
-        it('should get the video muted status and return as a boolean', () => {
-          const muted = meeting.isVideoMuted();
-
-          assert.isNotOk(muted);
-        });
-      });
-      describe('#isVideoSelf', () => {
-        it('should have #isVideoSelf', () => {
-          assert.exists(meeting.invite);
-        });
-        it('should get the video self status and return as a boolean', () => {
-          const self = meeting.isVideoSelf();
-
-          assert.isNotOk(self);
-        });
-      });
-      describe('#muteAudio', () => {
-        it('should have #muteAudio', () => {
-          assert.exists(meeting.muteAudio);
-        });
-        describe('before audio is defined', () => {
-          it('should reject and return a promise', async () => {
-            await meeting.muteAudio().catch((err) => {
-              assert.instanceOf(err, UserNotJoinedError);
-            });
-          });
-
-          it('should reject and return a promise', async () => {
-            meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-            await meeting.muteAudio().catch((err) => {
-              assert.instanceOf(err, NoMediaEstablishedYetError);
-            });
-          });
-
-          it('should reject and return a promise', async () => {
-            meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-            meeting.mediaId = 'mediaId';
-            await meeting.muteAudio().catch((err) => {
-              assert.instanceOf(err, ParameterError);
-            });
-          });
-        });
-        describe('after audio is defined', () => {
-          let handleClientRequest;
-
-          beforeEach(() => {
-            handleClientRequest = sinon.stub().returns(Promise.resolve());
-            meeting.audio = {handleClientRequest};
-          });
-
-          it('should return a promise resolution', async () => {
-            meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-            meeting.mediaId = 'mediaId';
-
-            const audio = meeting.muteAudio();
-
-            assert.exists(audio.then);
-            await audio;
-            assert.calledOnce(handleClientRequest);
-            assert.calledWith(handleClientRequest, meeting, true);
-          });
-        });
-      });
-      describe('#unmuteAudio', () => {
-        it('should have #unmuteAudio', () => {
-          assert.exists(meeting.unmuteAudio);
-        });
-        describe('before audio is defined', () => {
-          it('should reject when user not joined', async () => {
-            await meeting.unmuteAudio().catch((err) => {
-              assert.instanceOf(err, UserNotJoinedError);
-            });
-          });
-
-          it('should reject when no media is established yet ', async () => {
-            meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-            await meeting.unmuteAudio().catch((err) => {
-              assert.instanceOf(err, NoMediaEstablishedYetError);
-            });
-          });
-
-          it('should reject when audio is not there or established', async () => {
-            meeting.mediaId = 'mediaId';
-            meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-            await meeting.unmuteAudio().catch((err) => {
-              assert.instanceOf(err, ParameterError);
-            });
-          });
-        });
-        describe('after audio is defined', () => {
-          let handleClientRequest;
-
-          beforeEach(() => {
-            handleClientRequest = sinon.stub().returns(Promise.resolve());
-            meeting.mediaId = 'mediaId';
-            meeting.audio = {handleClientRequest};
-            meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-          });
-
-          it('should return a promise resolution', async () => {
-            meeting.audio = {handleClientRequest};
-
-            const audio = meeting.unmuteAudio();
-
-            assert.exists(audio.then);
-            await audio;
-            assert.calledOnce(handleClientRequest);
-            assert.calledWith(handleClientRequest, meeting, false);
-          });
-        });
-      });
-      describe('BNR', () => {
-        const fakeMediaTrack = () => ({
-          id: Date.now().toString(),
-          stop: () => {},
-          readyState: 'live',
-          enabled: true,
-          getSettings: () => ({
-            sampleRate: 48000,
-          }),
-        });
-
-        beforeEach(() => {
-          meeting.getMediaStreams = sinon.stub().returns(Promise.resolve());
-          sinon.replace(meeting, 'addMedia', () => {
-            sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack());
-            sinon.stub(meeting.mediaProperties, 'mediaDirection').value({
-              receiveAudio: true,
-            });
-          });
-        });
-        describe('#enableBNR', () => {
-          it('should have #enableBnr', () => {
-            assert.exists(meeting.enableBNR);
-          });
-
-          describe('before audio attached to meeting', () => {
-            it('should throw no audio error', async () => {
-              await meeting.enableBNR().catch((err) => {
-                assert.equal(err.toString(), "Error: Meeting doesn't have an audioTrack attached");
-              });
-            });
-          });
-
-          describe('after audio attached to meeting', () => {
-            let handleClientRequest;
-
-            beforeEach(async () => {
-              await meeting.getMediaStreams();
-              await meeting.addMedia();
-            });
-
-            it('should throw error if meeting audio is muted', async () => {
-              const handleClientRequest = (meeting, mute) => {
-                meeting.mediaProperties.audioTrack.enabled = !mute;
-
-                return Promise.resolve();
-              };
-              const isMuted = () => !meeting.mediaProperties.audioTrack.enabled;
-
-              meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-              meeting.mediaId = 'mediaId';
-              meeting.audio = {handleClientRequest, isMuted};
-              await meeting.muteAudio();
-              await meeting.enableBNR().catch((err) => {
-                assert.equal(err.message, 'Cannot enable BNR while meeting is muted');
-              });
-            });
-
-            it('should return true on enable bnr success', async () => {
-              handleClientRequest = sinon.stub().returns(Promise.resolve(true));
-              meeting.effects = {handleClientRequest};
-              const response = await meeting.enableBNR();
-
-              assert.equal(response, true);
-            });
-          });
-        });
-
-        describe('#disableBNR', () => {
-          describe('before audio attached to meeting', () => {
-            it('should have #disableBnr', () => {
-              assert.exists(meeting.disableBNR);
-            });
-
-            it('should throw no audio error', async () => {
-              await meeting.disableBNR().catch((err) => {
-                assert.equal(err.toString(), "Error: Meeting doesn't have an audioTrack attached");
-              });
-            });
-          });
-          describe('after audio attached to meeting', () => {
-            beforeEach(async () => {
-              await meeting.getMediaStreams();
-              await meeting.addMedia();
-            });
-
-            let handleClientRequest;
-            let isBnrEnabled;
-
-            it('should return true on disable bnr success', async () => {
-              handleClientRequest = sinon.stub().returns(Promise.resolve(true));
-              isBnrEnabled = sinon.stub().returns(Promise.resolve(true));
-              meeting.effects = {handleClientRequest, isBnrEnabled};
-              const response = await meeting.disableBNR();
-
-              assert.equal(response, true);
-            });
-          });
-        });
-      });
-      describe('#muteVideo', () => {
-        it('should have #muteVideo', () => {
-          assert.exists(meeting.muteVideo);
-        });
-        describe('before video is defined', () => {
-          it('should reject when user not joined', async () => {
-            await meeting.muteVideo().catch((err) => {
-              assert.instanceOf(err, UserNotJoinedError);
-            });
-          });
-
-          it('should reject when no media is established', async () => {
-            meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-            await meeting.muteVideo().catch((err) => {
-              assert.instanceOf(err, NoMediaEstablishedYetError);
-            });
-          });
-
-          it('should reject when no video added or established', async () => {
-            meeting.mediaId = 'mediaId';
-            meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-            await meeting.muteVideo().catch((err) => {
-              assert.instanceOf(err, ParameterError);
-            });
-          });
-        });
-        describe('after video is defined', () => {
-          it('should return a promise resolution', async () => {
-            const handleClientRequest = sinon.stub().returns(Promise.resolve());
-
-            meeting.mediaId = 'mediaId';
-            meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-            meeting.video = {handleClientRequest};
-            const video = meeting.muteVideo();
-
-            assert.exists(video.then);
-            await video;
-            assert.calledOnce(handleClientRequest);
-            assert.calledWith(handleClientRequest, meeting, true);
-          });
-        });
-      });
-      describe('#unmuteVideo', () => {
-        it('should have #unmuteVideo', () => {
-          assert.exists(meeting.unmuteVideo);
-        });
-        describe('before video is defined', () => {
-          it('should reject no user joined', async () => {
-            await meeting.unmuteVideo().catch((err) => {
-              assert.instanceOf(err, Error);
-            });
-          });
-
-          it('should reject no media established', async () => {
-            meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-            await meeting.unmuteVideo().catch((err) => {
-              assert.instanceOf(err, Error);
-            });
-          });
-
-          it('should reject when no video added or established', async () => {
-            meeting.mediaId = 'mediaId';
-            meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-            await meeting.unmuteVideo().catch((err) => {
-              assert.instanceOf(err, Error);
-            });
-          });
-        });
-        describe('after video is defined', () => {
-          it('should return a promise resolution', async () => {
-            const handleClientRequest = sinon.stub().returns(Promise.resolve());
 
-            meeting.mediaId = 'mediaId';
-            meeting.locusInfo.parsedLocus = {self: {state: 'JOINED'}};
-            meeting.video = {handleClientRequest};
-            const video = meeting.unmuteVideo();
-
-            assert.exists(video.then);
-            await video;
-            assert.calledOnce(handleClientRequest);
-            assert.calledWith(handleClientRequest, meeting, false);
-          });
-        });
-      });
       describe('#joinWithMedia', () => {
         it('should have #joinWithMedia', () => {
           assert.exists(meeting.joinWithMedia);
@@ -636,125 +492,21 @@ describe('plugin-meetings', () => {
         describe('resolution', () => {
           it('should success and return a promise', async () => {
             meeting.join = sinon.stub().returns(Promise.resolve(test1));
-            meeting.getMediaStreams = sinon.stub().returns(Promise.resolve([test2, test3]));
             meeting.addMedia = sinon.stub().returns(Promise.resolve(test4));
-            await meeting.joinWithMedia({});
+            const result = await meeting.joinWithMedia({});
             assert.calledOnce(meeting.join);
-            assert.calledOnce(meeting.getMediaStreams);
+            assert.calledOnce(meeting.addMedia);
+            assert.deepEqual(result, {join: test1, media: test4});
           });
         });
         describe('rejection', () => {
           it('should error out and return a promise', async () => {
             meeting.join = sinon.stub().returns(Promise.reject());
-            meeting.getMediaStreams = sinon.stub().returns(true);
             assert.isRejected(meeting.joinWithMedia({}));
           });
         });
       });
-      describe('#getMediaStreams', () => {
-        beforeEach(() => {
-          sinon
-            .stub(Media, 'getSupportedDevice')
-            .callsFake((options) =>
-              Promise.resolve({sendAudio: options.sendAudio, sendVideo: options.sendVideo})
-            );
-          sinon.stub(Media, 'getUserMedia').returns(Promise.resolve(['stream1', 'stream2']));
-        });
-        afterEach(() => {
-          sinon.restore();
-        });
-        it('should have #getMediaStreams', () => {
-          assert.exists(meeting.getMediaStreams);
-        });
-        it('should proxy Media getUserMedia, and return a promise', async () => {
-          await meeting.getMediaStreams({sendAudio: true, sendVideo: true});
-
-          assert.calledOnce(Media.getUserMedia);
-        });
-
-        it('uses the preferred video device if set', async () => {
-          const videoDevice = 'video1';
-          const mediaDirection = {sendAudio: true, sendVideo: true, sendShare: false};
-          const audioVideoSettings = {};
-
-          sinon.stub(meeting.mediaProperties, 'videoDeviceId').value(videoDevice);
-          sinon.stub(meeting.mediaProperties, 'localQualityLevel').value('480p');
-          await meeting.getMediaStreams(mediaDirection, audioVideoSettings);
-
-          assert.calledWith(
-            Media.getUserMedia,
-            {
-              ...mediaDirection,
-              isSharing: false,
-            },
-            {
-              video: {
-                width: {max: 640, ideal: 640},
-                height: {max: 480, ideal: 480},
-                deviceId: videoDevice,
-              },
-            }
-          );
-        });
-        it('will set a new preferred video input device if passed in', async () => {
-          // if audioVideo settings parameter specifies a new video device it
-          // will store that device as the preferred video device.
-          // Which is the case with meeting.updateVideo()
-          const oldVideoDevice = 'video1';
-          const newVideoDevice = 'video2';
-          const mediaDirection = {sendAudio: true, sendVideo: true, sendShare: false};
-          const audioVideoSettings = {video: {deviceId: newVideoDevice}};
-
-          sinon.stub(meeting.mediaProperties, 'videoDeviceId').value(oldVideoDevice);
-          sinon.stub(meeting.mediaProperties, 'setVideoDeviceId');
-
-          await meeting.getMediaStreams(mediaDirection, audioVideoSettings);
-
-          assert.calledWith(meeting.mediaProperties.setVideoDeviceId, newVideoDevice);
-        });
-
-        it('uses the passed custom video resolution', async () => {
-          const mediaDirection = {sendAudio: true, sendVideo: true, sendShare: false};
-          const customAudioVideoSettings = {
-            video: {
-              width: {
-                max: 400,
-                ideal: 400,
-              },
-              height: {
-                max: 200,
-                ideal: 200,
-              },
-              frameRate: {
-                ideal: 15,
-                max: 30,
-              },
-              facingMode: {
-                ideal: 'user',
-              },
-            },
-          };
-
-          sinon.stub(meeting.mediaProperties, 'localQualityLevel').value('200p');
-          await meeting.getMediaStreams(mediaDirection, customAudioVideoSettings);
-
-          assert.calledWith(
-            Media.getUserMedia,
-            {
-              ...mediaDirection,
-              isSharing: false,
-            },
-            customAudioVideoSettings
-          );
-        });
-        it('should not access camera if sendVideo is false ', async () => {
-          await meeting.getMediaStreams({sendAudio: true, sendVideo: false});
 
-          assert.calledOnce(Media.getUserMedia);
-
-          assert.equal(Media.getUserMedia.args[0][0].sendVideo, false);
-        });
-      });
       describe('#isTranscriptionSupported', () => {
         it('should return false if the feature is not supported for the meeting', () => {
           meeting.locusInfo.controls = {transcribe: {transcribing: false}};
@@ -779,7 +531,7 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('should throw error', async () => {
+        it("should throw error if request doesn't work", async () => {
           meeting.request = sinon.stub().returns(Promise.reject());
 
           try {
@@ -799,6 +551,64 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.transcription.closeSocket);
         });
       });
+      describe('#isReactionsSupported', () => {
+        it('should return false if the feature is not supported for the meeting', () => {
+          meeting.locusInfo.controls = {reactions: {enabled: false}};
+
+          assert.equal(meeting.isReactionsSupported(), false);
+        });
+        it('should return true if the feature is not supported for the meeting', () => {
+          meeting.locusInfo.controls = {reactions: {enabled: true}};
+
+          assert.equal(meeting.isReactionsSupported(), true);
+        });
+      });
+      describe('#processRelayEvent', () => {
+        it('should process a Reaction event type', () => {
+          meeting.isReactionsSupported = sinon.stub().returns(true);
+          meeting.config.receiveReactions = true;
+          const fakeSendersName = 'Fake reactors name';
+          meeting.members.membersCollection.get = sinon.stub().returns({name: fakeSendersName});
+          const fakeReactionPayload = {
+            type: 'fake_type',
+            codepoints: 'fake_codepoints',
+            shortcodes: 'fake_shortcodes',
+            tone: {
+              type: 'fake_tone_type',
+              codepoints: 'fake_tone_codepoints',
+              shortcodes: 'fake_tone_shortcodes',
+            },
+          };
+          const fakeSenderPayload = {
+            participantId: 'fake_participant_id',
+          };
+          const fakeProcessedReaction = {
+            reaction: fakeReactionPayload,
+            sender: {
+              id: fakeSenderPayload.participantId,
+              name: fakeSendersName,
+            },
+          };
+          const fakeRelayEvent = {
+            data: {
+              relayType: REACTION_RELAY_TYPES.REACTION,
+              reaction: fakeReactionPayload,
+              sender: fakeSenderPayload,
+            },
+          };
+          meeting.processRelayEvent(fakeRelayEvent);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            sinon.match.instanceOf(Meeting),
+            {
+              file: 'meeting/index',
+              function: 'join',
+            },
+            EVENT_TRIGGERS.MEETING_RECEIVE_REACTIONS,
+            fakeProcessedReaction
+          );
+        });
+      });
       describe('#join', () => {
         let sandbox = null;
         const joinMeetingResult = 'JOIN_MEETINGS_OPTION_RESULT';
@@ -873,8 +683,68 @@ describe('plugin-meetings', () => {
             await meeting.join();
             sinon.assert.called(meeting.setCorrelationId);
           });
-        });
-        describe('failure', () => {
+
+          it('should send Meeting Info CA events if meetingInfo is not empty', async () => {
+            meeting.meetingInfo = {info: 'info', meetingLookupUrl: 'url'};
+
+            const join = meeting.join();
+
+            assert.calledWithMatch(Metrics.postEvent, {
+              event: eventType.CALL_INITIATED,
+              data: {trigger: trigger.USER_INTERACTION, isRoapCallEnabled: true},
+            });
+
+            assert.exists(join.then);
+            const result = await join;
+
+            assert.calledOnce(MeetingUtil.joinMeeting);
+            assert.calledOnce(meeting.setLocus);
+            assert.equal(result, joinMeetingResult);
+
+            assert.calledThrice(Metrics.postEvent)
+
+            assert.deepEqual(Metrics.postEvent.getCall(0).args[0].event, 'client.call.initiated');
+            assert.deepEqual(Metrics.postEvent.getCall(0).args[0].data, {
+              isRoapCallEnabled: true,
+              trigger: 'user-interaction',
+            });
+            assert.deepEqual(
+              Metrics.postEvent.getCall(1).args[0].event,
+              'client.meetinginfo.request'
+            );
+            assert.deepEqual(Metrics.postEvent.getCall(1).args[0].data, undefined);
+            assert.deepEqual(
+              Metrics.postEvent.getCall(2).args[0].event,
+              'client.meetinginfo.response'
+            );
+            assert.deepEqual(Metrics.postEvent.getCall(2).args[0].data, {
+              meetingLookupUrl: 'url',
+            });
+          });
+
+          it('should not send Meeting Info CA events if meetingInfo is empty', async () => {
+            meeting.meetingInfo = {};
+
+            const join = meeting.join();
+
+            assert.calledWithMatch(Metrics.postEvent, {
+              event: eventType.CALL_INITIATED,
+              data: {trigger: trigger.USER_INTERACTION, isRoapCallEnabled: true},
+            });
+
+            assert.exists(join.then);
+            const result = await join;
+
+            assert.calledOnce(MeetingUtil.joinMeeting);
+            assert.calledOnce(meeting.setLocus);
+            assert.equal(result, joinMeetingResult);
+
+            assert.calledOnce(Metrics.postEvent)
+
+            assert.equal(Metrics.postEvent.getCall(0).args[0].event, 'client.call.initiated');
+          });
+        });
+        describe('failure', () => {
           beforeEach(() => {
             sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.reject());
             meeting.logger.log = sinon.stub().returns(true);
@@ -952,7 +822,7 @@ describe('plugin-meetings', () => {
         beforeEach(() => {
           fakeMediaConnection = {
             close: sinon.stub(),
-            getConnectionState: sinon.stub().returns(MC.ConnectionState.Connected),
+            getConnectionState: sinon.stub().returns(ConnectionState.Connected),
             initiateOffer: sinon.stub().resolves({}),
             on: sinon.stub(),
           };
@@ -961,7 +831,7 @@ describe('plugin-meetings', () => {
           meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
           meeting.audio = muteStateStub;
           meeting.video = muteStateStub;
-          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
+          sinon.stub(Media, 'createMediaConnection').returns(fakeMediaConnection);
           meeting.setMercuryListener = sinon.stub().returns(true);
           meeting.setupMediaConnectionListeners = sinon.stub();
           meeting.setMercuryListener = sinon.stub();
@@ -1022,6 +892,10 @@ describe('plugin-meetings', () => {
             code: error.code,
             turnDiscoverySkippedReason: undefined,
             turnServerUsed: true,
+            isMultistream: false,
+            signalingState: 'unknown',
+            connectionState: 'unknown',
+            iceConnectionState: 'unknown'
           });
         });
 
@@ -1038,8 +912,13 @@ describe('plugin-meetings', () => {
               locus_id: meeting.locusUrl.split('/').pop(),
               reason: err.message,
               stack: err.stack,
+              code: err.code,
               turnDiscoverySkippedReason: 'config',
               turnServerUsed: false,
+              isMultistream: false,
+              signalingState: 'unknown',
+              connectionState: 'unknown',
+              iceConnectionState: 'unknown'
             });
           });
         });
@@ -1053,21 +932,111 @@ describe('plugin-meetings', () => {
           });
           const result = await assert.isRejected(meeting.addMedia());
 
+
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE,
+            sinon.match({
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: result.message,
+              turnDiscoverySkippedReason: undefined,
+              turnServerUsed: true,
+              isMultistream: false,
+              signalingState: 'unknown',
+              connectionState: 'unknown',
+              iceConnectionState: 'unknown'
+            })
+          );
+
           assert.instanceOf(result, Error);
           assert.isNull(meeting.mediaProperties.webrtcMediaConnection);
 
+        });
+
+        it('should include the peer connection properties correctly for multistream', async () => {
+          meeting.meetingState = 'ACTIVE';
+          // setup the mock to return an incomplete object - this will cause addMedia to fail
+          // because some methods (like on() or initiateOffer()) are missing
+          Media.createMediaConnection = sinon.stub().returns({
+            close: sinon.stub(),
+            multistreamConnection :{
+              pc: {
+                pc: {
+                  signalingState: 'have-local-offer',
+                  connectionState: 'connecting',
+                  iceConnectionState: 'checking',
+                }
+              }
+            }
+          });
+          // set a statsAnalyzer on the meeting so that we can check that it gets reset to null
+          meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
+          const error = await assert.isRejected(meeting.addMedia());
+
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE,
+            sinon.match({
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: error.message,
+              stack: error.stack,
+              code: error.code,
+              turnDiscoverySkippedReason: undefined,
+              turnServerUsed: true,
+              isMultistream: false,
+              signalingState: 'have-local-offer',
+              connectionState: 'connecting',
+              iceConnectionState: 'checking'
+
+            })
+          );
+
+          assert.isNull(meeting.statsAnalyzer);
           assert(Metrics.sendBehavioralMetric.calledOnce);
+        });
+
+        it('should include the peer connection properties correctly for transcoded', async () => {
+          meeting.meetingState = 'ACTIVE';
+          // setup the mock to return an incomplete object - this will cause addMedia to fail
+          // because some methods (like on() or initiateOffer()) are missing
+          Media.createMediaConnection = sinon.stub().returns({
+            close: sinon.stub(),
+            mediaConnection :{
+              pc: {
+                signalingState: 'have-local-offer',
+                connectionState: 'connecting',
+                iceConnectionState: 'checking',
+              }
+            }
+          });
+          // set a statsAnalyzer on the meeting so that we can check that it gets reset to null
+          meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
+          const error = await assert.isRejected(meeting.addMedia());
+
           assert.calledWith(
             Metrics.sendBehavioralMetric,
             BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE,
             sinon.match({
               correlation_id: meeting.correlationId,
               locus_id: meeting.locusUrl.split('/').pop(),
-              reason: result.message,
+              reason: error.message,
+              stack: error.stack,
+              code: error.code,
               turnDiscoverySkippedReason: undefined,
               turnServerUsed: true,
+              isMultistream: false,
+              signalingState: 'have-local-offer',
+              connectionState: 'connecting',
+              iceConnectionState: 'checking'
+
             })
           );
+
+          assert.isNull(meeting.statsAnalyzer);
+          assert(Metrics.sendBehavioralMetric.calledOnce);
         });
 
         it('should work the second time addMedia is called in case the first time fails', async () => {
@@ -1198,9 +1167,7 @@ describe('plugin-meetings', () => {
 
         it('should attach the media and return WebExMeetingsErrors when connection does not reach CONNECTED state', async () => {
           meeting.meetingState = 'ACTIVE';
-          fakeMediaConnection.getConnectionState = sinon
-            .stub()
-            .returns(MC.ConnectionState.Connecting);
+          fakeMediaConnection.getConnectionState = sinon.stub().returns(ConnectionState.Connecting);
           const clock = sinon.useFakeTimers();
           const media = meeting.addMedia({
             mediaSettings: {},
@@ -1230,8 +1197,7 @@ describe('plugin-meetings', () => {
             .addMedia({
               mediaSettings: {},
             })
-            .catch((error) => {
-              assert.equal(error.code, IceGatheringFailed.CODE);
+            .catch(() => {
               errorThrown = true;
             });
 
@@ -1249,6 +1215,7 @@ describe('plugin-meetings', () => {
             correlation_id: meeting.correlationId,
             locus_id: meeting.locusUrl.split('/').pop(),
             connectionType: 'udp',
+            isMultistream: false
           });
         });
 
@@ -1366,627 +1333,853 @@ describe('plugin-meetings', () => {
             });
           });
         });
-      });
-      describe('#acknowledge', () => {
-        it('should have #acknowledge', () => {
-          assert.exists(meeting.acknowledge);
-        });
-        beforeEach(() => {
-          meeting.meetingRequest.acknowledgeMeeting = sinon.stub().returns(Promise.resolve());
-        });
-        it('should acknowledge incoming and return a promise', async () => {
-          const ack = meeting.acknowledge('INCOMING', false);
 
-          assert.exists(ack.then);
-          await ack;
-          assert.calledOnce(meeting.meetingRequest.acknowledgeMeeting);
-        });
-        it('should acknowledge a non incoming and return a promise', async () => {
-          const ack = meeting.acknowledge(test1, false);
+        it('should pass bundlePolicy to createMediaConnection', async () => {
+          const FAKE_TURN_URL = 'turns:webex.com:3478';
+          const FAKE_TURN_USER = 'some-turn-username';
+          const FAKE_TURN_PASSWORD = 'some-password';
 
-          assert.exists(ack.then);
-          await ack;
-          assert.notCalled(meeting.meetingRequest.acknowledgeMeeting);
-        });
-      });
-      describe('#decline', () => {
-        it('should have #decline', () => {
-          assert.exists(meeting.decline);
-        });
-        beforeEach(() => {
-          meeting.meetingRequest.declineMeeting = sinon.stub().returns(Promise.resolve());
-          meeting.meetingFiniteStateMachine.ring();
-        });
-        it('should decline the meeting and trigger meeting destroy for 1:1', async () => {
-          await meeting.decline();
-          assert.calledOnce(meeting.meetingRequest.declineMeeting);
+          meeting.meetingState = 'ACTIVE';
+          Media.createMediaConnection.resetHistory();
+
+          meeting.roap.doTurnDiscovery = sinon.stub().resolves({
+            turnServerInfo: {
+              url: FAKE_TURN_URL,
+              username: FAKE_TURN_USER,
+              password: FAKE_TURN_PASSWORD,
+            },
+            turnServerSkippedReason: undefined,
+          });
+          const media = meeting.addMedia({
+            mediaSettings: {},
+            bundlePolicy: 'bundlePolicy-value',
+          });
+
+          assert.exists(media);
+          await media;
+          assert.calledOnce(meeting.roap.doTurnDiscovery);
+          assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false);
+          assert.calledOnce(Media.createMediaConnection);
+          assert.calledWith(
+            Media.createMediaConnection,
+            false,
+            meeting.getMediaConnectionDebugId(),
+            sinon.match({
+              turnServerInfo: {
+                url: FAKE_TURN_URL,
+                username: FAKE_TURN_USER,
+                password: FAKE_TURN_PASSWORD,
+              },
+              bundlePolicy: 'bundlePolicy-value',
+            })
+          );
+          assert.calledOnce(fakeMediaConnection.initiateOffer);
         });
       });
-      describe('#leave', () => {
-        let sandbox;
 
-        it('should have #leave', () => {
-          assert.exists(meeting.leave);
-        });
+      /* This set of tests are like semi-integration tests, they use real MuteState, Media, LocusMediaRequest and Roap classes.
+         They mock the @webex/internal-media-core and sending of /media http requests to Locus.
+         Their main purpose is to test that we send the right http requests to Locus and make right calls
+         to @webex/internal-media-core when addMedia, updateMedia, publishTracks, unpublishTracks are called
+         in various combinations.
+      */
+      [true,false].forEach((isMultistream) =>
+      describe(`addMedia/updateMedia semi-integration tests (${isMultistream ? 'multistream' : 'transcoded'})`, () => {
+        const webrtcAudioTrack = {
+          id: 'underlying audio track',
+          getSettings: sinon.stub().returns({deviceId: 'fake device id for audio track'}),
+        };
 
-        it('should reject if meeting is already inactive', async () => {
-          await meeting.leave().catch((err) => {
-            assert.instanceOf(err, MeetingNotActiveError);
-          });
-        });
+        let fakeMicrophoneTrack;
+        let fakeRoapMediaConnection;
+        let fakeMultistreamRoapMediaConnection;
+        let roapMediaConnectionConstructorStub;
+        let multistreamRoapMediaConnectionConstructorStub;
+        let locusMediaRequestStub; // stub for /media requests to Locus
 
-        it('should reject if meeting is already left', async () => {
-          meeting.meetingState = 'ACTIVE';
-          await meeting.leave().catch((err) => {
-            assert.instanceOf(err, UserNotJoinedError);
-          });
-        });
+        const roapOfferMessage = {messageType: 'OFFER', sdp: 'sdp', seq: '1', tieBreaker: '123'};
+
+        let expectedMediaConnectionConfig;
+        let expectedDebugId;
+
+        let clock;
 
         beforeEach(() => {
-          sandbox = sinon.createSandbox();
-          meeting.meetingFiniteStateMachine.ring();
-          meeting.meetingFiniteStateMachine.join();
-          meeting.meetingRequest.leaveMeeting = sinon
-            .stub()
-            .returns(Promise.resolve({body: 'test'}));
-          meeting.locusInfo.onFullLocus = sinon.stub().returns(true);
-          // the 3 need to be promises because we do closeLocalStream.then(closeLocalShare.then) etc in the src code
-          meeting.closeLocalStream = sinon.stub().returns(Promise.resolve());
-          meeting.closeLocalShare = sinon.stub().returns(Promise.resolve());
-          meeting.closeRemoteStream = sinon.stub().returns(Promise.resolve());
-          sandbox.stub(meeting, 'closeRemoteTracks').returns(Promise.resolve());
-          meeting.closePeerConnections = sinon.stub().returns(Promise.resolve());
-          meeting.unsetLocalVideoTrack = sinon.stub().returns(true);
-          meeting.unsetLocalShareTrack = sinon.stub().returns(true);
-          meeting.unsetRemoteTracks = sinon.stub();
-          meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
-          meeting.unsetRemoteStream = sinon.stub().returns(true);
-          meeting.unsetPeerConnections = sinon.stub().returns(true);
-          meeting.logger.error = sinon.stub().returns(true);
-          meeting.updateLLMConnection = sinon.stub().returns(Promise.resolve());
+          clock = sinon.useFakeTimers();
 
-          // A meeting needs to be joined to leave
+          meeting.deviceUrl = 'deviceUrl';
+          meeting.config.deviceType = 'web';
+          meeting.isMultistream = isMultistream;
           meeting.meetingState = 'ACTIVE';
-          meeting.state = 'JOINED';
-        });
-        afterEach(() => {
-          sandbox.restore();
-          sandbox = null;
-        });
-        it('should leave the meeting and return promise', async () => {
-          const leave = meeting.leave();
+          meeting.mediaId = 'fake media id';
+          meeting.selfUrl = 'selfUrl';
+          meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
+          meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
+          meeting.setMercuryListener = sinon.stub();
+          meeting.locusInfo.onFullLocus = sinon.stub();
+          meeting.webex.meetings.reachability = {
+            isAnyClusterReachable: sinon.stub().resolves(true),
+          };
+          meeting.roap.doTurnDiscovery = sinon
+            .stub()
+            .resolves({turnServerInfo: {}, turnDiscoverySkippedReason: 'reachability'});
+
+          StaticConfig.set({bandwidth: {audio: 1234, video: 5678, startBitrate: 9876}});
+
+          Metrics.postEvent = sinon.stub();
+
+          // setup things that are expected to be the same across all the tests and are actually irrelevant for these tests
+          expectedDebugId = `MC-${meeting.id.substring(0, 4)}`;
+          expectedMediaConnectionConfig = {
+            iceServers: [ { urls: undefined, username: '', credential: '' } ],
+            skipInactiveTransceivers: false,
+            requireH264: true,
+            sdpMunging: {
+              convertPort9to0: false,
+              addContentSlides: true,
+              bandwidthLimits: {
+                audio: StaticConfig.meetings.bandwidth.audio,
+                video: StaticConfig.meetings.bandwidth.video,
+              },
+              startBitrate: StaticConfig.meetings.bandwidth.startBitrate,
+              periodicKeyframes: 20,
+              disableExtmap: !meeting.config.enableExtmap,
+              disableRtx: !meeting.config.enableRtx,
+            },
+          };
 
-          assert.exists(leave.then);
-          await leave;
-          assert.calledOnce(meeting.meetingRequest.leaveMeeting);
-          assert.calledOnce(meeting.closeLocalStream);
-          assert.calledOnce(meeting.closeLocalShare);
-          assert.calledOnce(meeting.closeRemoteTracks);
-          assert.calledOnce(meeting.closePeerConnections);
-          assert.calledOnce(meeting.unsetLocalVideoTrack);
-          assert.calledOnce(meeting.unsetLocalShareTrack);
-          assert.calledOnce(meeting.unsetRemoteTracks);
-          assert.calledOnce(meeting.unsetPeerConnections);
-        });
-        describe('after audio/video is defined', () => {
-          let handleClientRequest;
+          // setup stubs
+          fakeMicrophoneTrack = {
+            id: 'fake mic',
+            on: sinon.stub(),
+            off: sinon.stub(),
+            setUnmuteAllowed: sinon.stub(),
+            setMuted: sinon.stub(),
+            setPublished: sinon.stub(),
+            muted: false,
+            underlyingTrack: webrtcAudioTrack
+          };
 
-          beforeEach(() => {
-            handleClientRequest = sinon.stub().returns(Promise.resolve(true));
+          fakeRoapMediaConnection = {
+            id: 'roap media connection',
+            close: sinon.stub(),
+            getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+            initiateOffer: sinon.stub().resolves({}),
+            update: sinon.stub().resolves({}),
+            on: sinon.stub(),
+          };
 
-            meeting.audio = {handleClientRequest};
-            meeting.video = {handleClientRequest};
-          });
+          fakeMultistreamRoapMediaConnection = {
+            id: 'multistream roap media connection',
+            close: sinon.stub(),
+            getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+            initiateOffer: sinon.stub().resolves({}),
+            publishTrack: sinon.stub().resolves({}),
+            unpublishTrack: sinon.stub().resolves({}),
+            on: sinon.stub(),
+            requestMedia: sinon.stub(),
+            createReceiveSlot: sinon.stub().resolves({on: sinon.stub()}),
+            enableMultistreamAudio: sinon.stub(),
+          };
 
-          it('should delete audio and video state machines when leaving the meeting', async () => {
-            const leave = meeting.leave();
+          roapMediaConnectionConstructorStub = sinon
+            .stub(internalMediaModule, 'RoapMediaConnection')
+            .returns(fakeRoapMediaConnection);
 
-            assert.exists(leave.then);
-            await leave;
+          multistreamRoapMediaConnectionConstructorStub = sinon
+            .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+            .returns(fakeMultistreamRoapMediaConnection);
 
-            assert.isNull(meeting.audio);
-            assert.isNull(meeting.video);
-          });
+          locusMediaRequestStub = sinon.stub(WebexPlugin.prototype, 'request').resolves({body: {locus: { fullState: {}}}});
         });
-        it('should leave the meeting without leaving resource', async () => {
-          const leave = meeting.leave({resourceId: null});
 
-          assert.exists(leave.then);
-          await leave;
-          assert.calledWith(meeting.meetingRequest.leaveMeeting, {
-            locusUrl: meeting.locusUrl,
-            correlationId: meeting.correlationId,
-            selfId: meeting.selfId,
-            resourceId: null,
-            deviceUrl: meeting.deviceUrl,
-          });
+        afterEach(() => {
+          clock.restore();
         });
-        it('should leave the meeting on the resource', async () => {
-          const leave = meeting.leave();
 
-          assert.exists(leave.then);
-          await leave;
-          assert.calledWith(meeting.meetingRequest.leaveMeeting, {
-            locusUrl: meeting.locusUrl,
-            correlationId: meeting.correlationId,
-            selfId: meeting.selfId,
-            resourceId: meeting.resourceId,
-            deviceUrl: meeting.deviceUrl,
+        // helper function that waits until all promises are resolved and any queued up /media requests to Locus are sent out
+        const stableState = async () => {
+          await testUtils.flushPromises();
+          clock.tick(1); // needed because LocusMediaRequest uses Lodash.defer()
+        }
+
+        const resetHistory = () => {
+          locusMediaRequestStub.resetHistory();
+          fakeRoapMediaConnection.update.resetHistory();
+          fakeMultistreamRoapMediaConnection.publishTrack.resetHistory();
+          fakeMultistreamRoapMediaConnection.unpublishTrack.resetHistory();
+        };
+
+        const getRoapListener = () => {
+          const roapMediaConnectionToCheck = isMultistream ? fakeMultistreamRoapMediaConnection : fakeRoapMediaConnection;
+
+          for(let idx = 0; idx < roapMediaConnectionToCheck.on.callCount; idx+= 1) {
+            if (roapMediaConnectionToCheck.on.getCall(idx).args[0] === Event.ROAP_MESSAGE_TO_SEND) {
+              return roapMediaConnectionToCheck.on.getCall(idx).args[1];
+            }
+          }
+          assert.fail('listener for "roap:messageToSend" (Event.ROAP_MESSAGE_TO_SEND) was not registered')
+        }
+
+        // simulates a Roap offer being generated by the RoapMediaConnection
+        const simulateRoapOffer = async () => {
+          const roapListener = getRoapListener();
+
+          await roapListener({roapMessage: roapOfferMessage});
+          await stableState();
+        }
+
+        const checkSdpOfferSent = ({audioMuted, videoMuted}) => {
+          const {sdp, seq, tieBreaker} = roapOfferMessage;
+
+          assert.calledWith(locusMediaRequestStub,
+            {
+              method: 'PUT',
+              uri: `${meeting.selfUrl}/media`,
+              body: {
+                device: { url: meeting.deviceUrl, deviceType: meeting.config.deviceType },
+                correlationId: meeting.correlationId,
+                localMedias: [
+                  {
+                    localSdp: `{"audioMuted":${audioMuted},"videoMuted":${videoMuted},"roapMessage":{"messageType":"OFFER","sdps":["${sdp}"],"version":"2","seq":"${seq}","tieBreaker":"${tieBreaker}"}}`,
+                    mediaId: 'fake media id'
+                  }
+                ],
+                clientMediaPreferences: {
+                  preferTranscoding: !meeting.isMultistream,
+                  joinCookie: undefined
+                }
+              },
+            });
+        };
+
+        const checkLocalMuteSentToLocus = ({audioMuted, videoMuted}) => {
+          assert.calledWith(locusMediaRequestStub, {
+              method: 'PUT',
+              uri: `${meeting.selfUrl}/media`,
+              body: {
+                device: { url: meeting.deviceUrl, deviceType: meeting.config.deviceType },
+                correlationId: meeting.correlationId,
+                localMedias: [
+                  {
+                    localSdp: `{"audioMuted":${audioMuted},"videoMuted":${videoMuted}}`,
+                    mediaId: 'fake media id'
+                  }
+                ],
+                clientMediaPreferences: {
+                  preferTranscoding: !meeting.isMultistream,
+                },
+                respOnlySdp: true,
+                usingResource: null,
+              },
+            });
+        };
+
+        const checkMediaConnectionCreated = ({mediaConnectionConfig, localTracks, direction, remoteQualityLevel, expectedDebugId}) => {
+          if (isMultistream) {
+            const {iceServers} = mediaConnectionConfig;
+
+            assert.calledOnceWithExactly(multistreamRoapMediaConnectionConstructorStub, {
+              iceServers,
+              enableMainAudio: direction.audio !== 'inactive',
+              enableMainVideo: true
+            }, expectedDebugId);
+
+            Object.values(localTracks).forEach((track) => {
+              if (track) {
+                assert.calledOnceWithExactly(fakeMultistreamRoapMediaConnection.publishTrack, track);
+              }
+            })
+          } else {
+            assert.calledOnceWithExactly(roapMediaConnectionConstructorStub, mediaConnectionConfig,
+              {
+                localTracks: {
+                  audio: localTracks.audio?.underlyingTrack,
+                  video: localTracks.video?.underlyingTrack,
+                  screenShareVideo: localTracks.screenShareVideo?.underlyingTrack,
+                },
+                direction,
+                remoteQualityLevel,
+              },
+              expectedDebugId);
+          }
+        }
+
+        it('addMedia() works correctly when media is enabled without tracks to publish', async () => {
+          await meeting.addMedia();
+          await simulateRoapOffer();
+
+          // check RoapMediaConnection was created correctly
+          checkMediaConnectionCreated({
+            mediaConnectionConfig: expectedMediaConnectionConfig,
+            localTracks: {
+              audio: undefined,
+              video: undefined,
+              screenShareVideo: undefined,
+            },
+            direction: {
+              audio: 'sendrecv',
+              video: 'sendrecv',
+              screenShareVideo: 'recvonly',
+            },
+            remoteQualityLevel: 'HIGH',
+            expectedDebugId,
           });
-        });
-      });
-      describe('#requestScreenShareFloor', () => {
-        it('should have #requestScreenShareFloor', () => {
-          assert.exists(meeting.requestScreenShareFloor);
-        });
-        beforeEach(() => {
-          meeting.locusInfo.mediaShares = [{name: 'content', url: url1}];
-          meeting.locusInfo.self = {url: url1};
-          meeting.meetingRequest.changeMeetingFloor = sinon.stub().returns(Promise.resolve());
-        });
-        it('should send the share', async () => {
-          const share = meeting.requestScreenShareFloor();
 
-          assert.exists(share.then);
-          await share;
-          assert.calledOnce(meeting.meetingRequest.changeMeetingFloor);
+          // and SDP offer was sent with the right audioMuted/videoMuted values
+          checkSdpOfferSent({audioMuted: true, videoMuted: true});
+
+          // and that it was the only /media request that was sent
+          assert.calledOnce(locusMediaRequestStub);
         });
-      });
 
-      describe('#shareScreen', () => {
-        let _mediaDirection;
+        it('addMedia() works correctly when media is enabled with tracks to publish', async () => {
+          await meeting.addMedia({localTracks: {microphone: fakeMicrophoneTrack}});
+          await simulateRoapOffer();
 
-        beforeEach(() => {
-          _mediaDirection = meeting.mediaProperties.mediaDirection || {};
-          sinon
-            .stub(meeting.mediaProperties, 'mediaDirection')
-            .value({sendAudio: true, sendVideo: true, sendShare: false});
-        });
+          // check RoapMediaConnection was created correctly
+          checkMediaConnectionCreated({
+            mediaConnectionConfig: expectedMediaConnectionConfig,
+            localTracks: {
+              audio: fakeMicrophoneTrack,
+              video: undefined,
+              screenShareVideo: undefined,
+            },
+            direction: {
+              audio: 'sendrecv',
+              video: 'sendrecv',
+              screenShareVideo: 'recvonly',
+            },
+            remoteQualityLevel: 'HIGH',
+            expectedDebugId
+          });
 
-        afterEach(() => {
-          meeting.mediaProperties.mediaDirection = _mediaDirection;
-        });
+          // and SDP offer was sent with the right audioMuted/videoMuted values
+          checkSdpOfferSent({audioMuted: false, videoMuted: true});
 
-        it('should have #shareScreen', () => {
-          assert.exists(meeting.shareScreen);
+          // and no other local mute requests were sent to Locus
+          assert.calledOnce(locusMediaRequestStub);
         });
 
-        describe('basic functionality', () => {
-          beforeEach(() => {
-            sinon.stub(Media, 'getDisplayMedia').returns(Promise.resolve());
-            sinon.stub(meeting, 'updateShare').returns(Promise.resolve());
-          });
+        it('addMedia() works correctly when media is enabled with tracks to publish and track is muted', async () => {
+          fakeMicrophoneTrack.muted = true;
 
-          afterEach(() => {
-            Media.getDisplayMedia.restore();
-            meeting.updateShare.restore();
+          await meeting.addMedia({localTracks: {microphone: fakeMicrophoneTrack}});
+          await simulateRoapOffer();
+
+          // check RoapMediaConnection was created correctly
+          checkMediaConnectionCreated({
+            mediaConnectionConfig: expectedMediaConnectionConfig,
+            localTracks: {
+              audio: fakeMicrophoneTrack,
+              video: undefined,
+              screenShareVideo: undefined,
+            },
+            direction: {
+              audio: 'sendrecv',
+              video: 'sendrecv',
+              screenShareVideo: 'recvonly',
+            },
+            remoteQualityLevel: 'HIGH',
+            expectedDebugId,
           });
 
-          it('should call get display media', async () => {
-            await meeting.shareScreen();
+          // and SDP offer was sent with the right audioMuted/videoMuted values
+          checkSdpOfferSent({audioMuted: true, videoMuted: true});
 
-            assert.calledOnce(Media.getDisplayMedia);
-          });
+          // and no other local mute requests were sent to Locus
+          assert.calledOnce(locusMediaRequestStub);
+        });
 
-          it('should call updateShare', async () => {
-            await meeting.shareScreen();
+        it('addMedia() works correctly when media is disabled with tracks to publish', async () => {
+          await meeting.addMedia({localTracks: {microphone: fakeMicrophoneTrack}, audioEnabled: false});
+          await simulateRoapOffer();
 
-            assert.calledOnce(meeting.updateShare);
+          // check RoapMediaConnection was created correctly
+          checkMediaConnectionCreated({
+            mediaConnectionConfig: expectedMediaConnectionConfig,
+            localTracks: {
+              audio: fakeMicrophoneTrack,
+              video: undefined,
+              screenShareVideo: undefined,
+            },
+            direction: {
+              audio: 'inactive',
+              video: 'sendrecv',
+              screenShareVideo: 'recvonly',
+            },
+            remoteQualityLevel: 'HIGH',
+            expectedDebugId
           });
 
-          it('properly assigns default values', async () => {
-            await meeting.shareScreen({sharePreferences: {highFrameRate: true}});
+          // and SDP offer was sent with the right audioMuted/videoMuted values
+          checkSdpOfferSent({audioMuted: true, videoMuted: true});
 
-            assert.calledWith(Media.getDisplayMedia, {
-              sendShare: true,
-              sendAudio: false,
-              sharePreferences: {highFrameRate: true},
-            });
-          });
+          // and no other local mute requests were sent to Locus
+          assert.calledOnce(locusMediaRequestStub);
         });
 
-        describe('stops share immediately', () => {
-          let sandbox;
+        it('addMedia() works correctly when media is disabled with no tracks to publish', async () => {
+          await meeting.addMedia({audioEnabled: false});
+          await simulateRoapOffer();
 
-          beforeEach(() => {
-            sandbox = sinon.createSandbox();
+          // check RoapMediaConnection was created correctly
+          checkMediaConnectionCreated({
+            mediaConnectionConfig: expectedMediaConnectionConfig,
+            localTracks: {
+              audio: undefined,
+              video: undefined,
+              screenShareVideo: undefined,
+            },
+            direction: {
+              audio: 'inactive',
+              video: 'sendrecv',
+              screenShareVideo: 'recvonly',
+            },
+            remoteQualityLevel: 'HIGH',
+            expectedDebugId
           });
 
-          afterEach(() => {
-            sandbox.restore();
-            sandbox = null;
-          });
+          // and SDP offer was sent with the right audioMuted/videoMuted values
+          checkSdpOfferSent({audioMuted: true, videoMuted: true});
 
-          it('Can bypass canUpdateMedia() check', () => {
-            const sendShare = true;
-            const receiveShare = false;
-            const stream = 'stream';
+          // and no other local mute requests were sent to Locus
+          assert.calledOnce(locusMediaRequestStub);
+        });
 
-            sandbox.stub(MeetingUtil, 'getTrack').returns({videoTrack: true});
-            MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve(true));
-            sandbox.stub(meeting, 'canUpdateMedia').returns(true);
-            sandbox.stub(meeting, 'setLocalShareTrack');
+        describe('publishTracks()/unpublishTracks() calls', () => {
+          [
+            {mediaEnabled: true, expected: {direction: 'sendrecv', localMuteSentValue: false}},
+            {mediaEnabled: false, expected: {direction: 'inactive', localMuteSentValue: undefined}}
+          ]
+            .forEach(({mediaEnabled, expected}) => {
+              it(`first publishTracks() call while media is ${mediaEnabled ? 'enabled' : 'disabled'}`, async () => {
+                await meeting.addMedia({audioEnabled: mediaEnabled});
+                await simulateRoapOffer();
 
-            meeting.updateShare({
-              sendShare,
-              receiveShare,
-              stream,
-              skipSignalingCheck: true,
-            });
+                resetHistory();
 
-            assert.notCalled(meeting.canUpdateMedia);
-          });
+                await meeting.publishTracks({microphone: fakeMicrophoneTrack});
+                await stableState();
 
-          it('skips canUpdateMedia() check on contentTracks.onended', () => {
-            const {mediaProperties} = meeting;
-            const fakeTrack = {
-              getSettings: sinon.stub().returns({}),
-              onended: sinon.stub(),
-            };
+                if (expected.localMuteSentValue !== undefined) {
+                  // check local mute was sent and it was the only /media request
+                  checkLocalMuteSentToLocus({audioMuted: expected.localMuteSentValue, videoMuted: true});
+                  assert.calledOnce(locusMediaRequestStub);
+                } else {
+                  assert.notCalled(locusMediaRequestStub);
+                }
+                if (isMultistream) {
+                  assert.calledOnceWithExactly(fakeMultistreamRoapMediaConnection.publishTrack, fakeMicrophoneTrack);
+                } else {
+                  assert.calledOnceWithExactly(fakeRoapMediaConnection.update, {
+                    localTracks: { audio: webrtcAudioTrack, video: null, screenShareVideo: null },
+                    direction: {
+                      audio: expected.direction,
+                      video: 'sendrecv',
+                      screenShareVideo: 'recvonly',
+                    },
+                    remoteQualityLevel: 'HIGH'
+                  });
+                }
+              });
 
-            sandbox.stub(mediaProperties, 'setLocalShareTrack');
-            sandbox.stub(mediaProperties, 'shareTrack').value(fakeTrack);
-            sandbox.stub(mediaProperties, 'setMediaSettings');
-            sandbox.stub(meeting, 'stopShare').resolves(true);
-            meeting.setLocalShareTrack(fakeTrack);
+              it(`second publishTracks() call while media is ${mediaEnabled ? 'enabled' : 'disabled'}`, async () => {
+                await meeting.addMedia({audioEnabled: mediaEnabled});
+                await simulateRoapOffer();
+                await meeting.publishTracks({microphone: fakeMicrophoneTrack});
+                await stableState();
+
+                resetHistory();
+
+                const webrtcAudioTrack2 = {id: 'underlying audio track 2'};
+                const fakeMicrophoneTrack2 = {
+                  id: 'fake mic 2',
+                  on: sinon.stub(),
+                  off: sinon.stub(),
+                  setUnmuteAllowed: sinon.stub(),
+                  setMuted: sinon.stub(),
+                  setPublished: sinon.stub(),
+                  muted: false,
+                  underlyingTrack: webrtcAudioTrack2
+                };
+
+                await meeting.publishTracks({microphone: fakeMicrophoneTrack2});
+                await stableState();
+
+                // only the roap media connection should be updated
+                if (isMultistream) {
+                  assert.calledOnceWithExactly(fakeMultistreamRoapMediaConnection.publishTrack, fakeMicrophoneTrack2);
+                } else {
+                  assert.calledOnceWithExactly(fakeRoapMediaConnection.update, {
+                    localTracks: { audio: webrtcAudioTrack2, video: null, screenShareVideo: null },
+                    direction: {
+                      audio: expected.direction,
+                      video: 'sendrecv',
+                      screenShareVideo: 'recvonly',
+                    },
+                    remoteQualityLevel: 'HIGH'
+                  });
+                }
 
-            fakeTrack.onended();
+                // and no other roap messages or local mute requests were sent
+                assert.notCalled(locusMediaRequestStub);
+              });
 
-            assert.calledWith(meeting.stopShare, {skipSignalingCheck: true});
-          });
+              it(`unpublishTracks() call while media is ${mediaEnabled ? 'enabled' : 'disabled'}`, async () => {
+                await meeting.addMedia({audioEnabled: mediaEnabled});
+                await simulateRoapOffer();
+                await meeting.publishTracks({microphone: fakeMicrophoneTrack});
+                await stableState();
 
-          it('stopShare accepts and passes along optional parameters', () => {
-            const args = {
-              abc: 123,
-              receiveShare: false,
-              sendShare: false,
-            };
+                resetHistory();
 
-            sandbox.stub(meeting, 'updateShare').returns(Promise.resolve());
-            sandbox.stub(meeting.mediaProperties, 'mediaDirection').value(false);
+                await meeting.unpublishTracks([fakeMicrophoneTrack]);
+                await stableState();
 
-            meeting.stopShare(args);
+                // the roap media connection should be updated
+                if (isMultistream) {
+                  assert.calledOnceWithExactly(fakeMultistreamRoapMediaConnection.unpublishTrack, fakeMicrophoneTrack);
+                } else {
+                  assert.calledOnceWithExactly(fakeRoapMediaConnection.update, {
+                    localTracks: { audio: null, video: null, screenShareVideo: null },
+                    direction: {
+                      audio: expected.direction,
+                      video: 'sendrecv',
+                      screenShareVideo: 'recvonly',
+                    },
+                    remoteQualityLevel: 'HIGH'
+                  });
+                }
 
-            assert.calledWith(meeting.updateShare, args);
-          });
+                if (expected.localMuteSentValue !== undefined) {
+                  // and local mute sent to Locus
+                  checkLocalMuteSentToLocus({audioMuted: !expected.localMuteSentValue /* negation, because we're un-publishing */, videoMuted: true});
+                  assert.calledOnce(locusMediaRequestStub);
+                } else {
+                  assert.notCalled(locusMediaRequestStub);
+                }
+              });
+            });
         });
 
-        describe('out-of-sync sharing', () => {
-          let sandbox;
+        describe('updateMedia()', () => {
 
-          beforeEach(() => {
-            sandbox = sinon.createSandbox();
+          const addMedia = async (enableMedia, track) => {
+            await meeting.addMedia({audioEnabled: enableMedia, localTracks: {microphone: track}});
+            await simulateRoapOffer();
+
+            resetHistory();
+          }
+
+          const checkAudioEnabled = (expectedTrack, expectedDirection) => {
+            if (isMultistream) {
+              assert.calledOnceWithExactly(fakeMultistreamRoapMediaConnection.enableMultistreamAudio, expectedDirection !== 'inactive');
+            } else {
+              assert.calledOnceWithExactly(fakeRoapMediaConnection.update, {
+                localTracks: { audio: expectedTrack, video: null, screenShareVideo: null },
+                direction: {
+                  audio: expectedDirection,
+                  video: 'sendrecv',
+                  screenShareVideo: 'recvonly',
+                },
+                remoteQualityLevel: 'HIGH'
+              });
+            }
+          }
+
+          it('updateMedia() disables media when nothing is published', async () => {
+            await addMedia(true);
+
+            await meeting.updateMedia({audioEnabled: false});
+
+            // the roap media connection should be updated
+            checkAudioEnabled(null, 'inactive');
+
+            // and that would trigger a new offer so we simulate it happening
+            await simulateRoapOffer();
+
+            // check SDP offer was sent with the right audioMuted/videoMuted values
+            checkSdpOfferSent({audioMuted: true, videoMuted: true});
+
+            // and no other local mute requests were sent to Locus
+            assert.calledOnce(locusMediaRequestStub);
           });
 
-          afterEach(() => {
-            sandbox.restore();
-            sandbox = null;
+          it('updateMedia() enables media when nothing is published', async () => {
+            await addMedia(false);
+
+            await meeting.updateMedia({audioEnabled: true});
+
+            // the roap media connection should be updated
+            checkAudioEnabled(null, 'sendrecv');
+
+            // and that would trigger a new offer so we simulate it happening
+            await simulateRoapOffer();
+
+            // check SDP offer was sent with the right audioMuted/videoMuted values
+            checkSdpOfferSent({audioMuted: true, videoMuted: true});
+
+            // and no other local mute requests were sent to Locus
+            assert.calledOnce(locusMediaRequestStub);
           });
 
-          it('handleShareTrackEnded triggers an event', () => {
-            const stream = 'stream';
-            const {EVENT_TYPES} = CONSTANTS;
+          it('updateMedia() disables media when track is published', async () => {
+            await addMedia(true, fakeMicrophoneTrack);
 
-            sandbox.stub(meeting, 'stopShare').resolves(true);
+            await meeting.updateMedia({audioEnabled: false});
+            await stableState();
 
-            meeting.handleShareTrackEnded(stream);
+            // the roap media connection should be updated
+            checkAudioEnabled(webrtcAudioTrack, 'inactive');
 
-            assert.calledWith(
-              TriggerProxy.trigger,
-              sinon.match.instanceOf(Meeting),
-              {
-                file: 'meeting/index',
-                function: 'handleShareTrackEnded',
-              },
-              EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
-              {
-                stream,
-                type: EVENT_TYPES.LOCAL_SHARE,
-              }
-            );
+            checkLocalMuteSentToLocus({audioMuted: true, videoMuted: true});
+
+            locusMediaRequestStub.resetHistory();
+
+            // and that would trigger a new offer so we simulate it happening
+            await simulateRoapOffer();
+
+            // check SDP offer was sent with the right audioMuted/videoMuted values
+            checkSdpOfferSent({audioMuted: true, videoMuted: true});
+
+            // and no other local mute requests were sent to Locus
+            assert.calledOnce(locusMediaRequestStub);
           });
-        });
-      });
 
-      describe('#shareScreen resolutions', () => {
-        let _getDisplayMedia = null;
-        const config = DefaultSDKConfig.meetings;
-        const {resolution} = config;
-        const shareOptions = {
-          sendShare: true,
-          sendAudio: false,
-        };
-        const fireFoxOptions = {
-          audio: false,
-          video: {
-            audio: shareOptions.sendAudio,
-            video: shareOptions.sendShare,
-          },
-        };
+          it('updateMedia() enables media when track is published', async () => {
+            await addMedia(false, fakeMicrophoneTrack);
 
-        const MediaStream = {
-          getVideoTracks: () => [
-            {
-              applyConstraints: () => {},
-            },
-          ],
-        };
+            await meeting.updateMedia({audioEnabled: true});
+            await stableState();
 
-        const MediaConstraint = {
-          cursor: 'always',
-          aspectRatio: config.aspectRatio,
-          frameRate: config.screenFrameRate,
-          width: null,
-          height: null,
-        };
+            // the roap media connection should be updated
+            checkAudioEnabled(webrtcAudioTrack, 'sendrecv');
 
-        const browserConditionalValue = (value) => {
-          const key = getBrowserName().toLowerCase();
-          const defaultKey = 'default';
+            checkLocalMuteSentToLocus({audioMuted: false, videoMuted: true});
 
-          return value[key] || value[defaultKey];
-        };
+            locusMediaRequestStub.resetHistory();
 
-        before(() => {
-          meeting.updateShare = sinon.stub().returns(Promise.resolve());
+            // and that would trigger a new offer so we simulate it happening
+            await simulateRoapOffer();
 
-          if (!global.navigator) {
-            global.navigator = {
-              mediaDevices: {
-                getDisplayMedia: null,
-              },
-            };
-          }
-          _getDisplayMedia = global.navigator.mediaDevices.getDisplayMedia;
-          Object.defineProperty(global.navigator.mediaDevices, 'getDisplayMedia', {
-            value: sinon.stub().returns(Promise.resolve(MediaStream)),
-            writable: true,
+            // check SDP offer was sent with the right audioMuted/videoMuted values
+            checkSdpOfferSent({audioMuted: false, videoMuted: true});
+
+            // and no other local mute requests were sent to Locus
+            assert.calledOnce(locusMediaRequestStub);
           });
         });
 
-        after(() => {
-          // clean up for browser
-          Object.defineProperty(global.navigator.mediaDevices, 'getDisplayMedia', {
-            value: _getDisplayMedia,
-            writable: true,
-          });
+        [
+          {mute: true, title: 'muting a track before confluence is created'},
+          {mute: false, title: 'unmuting a track before confluence is created'}
+        ].forEach(({mute, title}) =>
+          it(title, async () => {
+            // initialize the microphone mute state to opposite of what we do in the test
+            fakeMicrophoneTrack.muted = !mute;
+
+            await meeting.addMedia({localTracks: {microphone: fakeMicrophoneTrack}});
+            await stableState();
+
+            resetHistory();
+
+            assert.equal(fakeMicrophoneTrack.on.getCall(0).args[0], LocalTrackEvents.Muted);
+            const mutedListener = fakeMicrophoneTrack.on.getCall(0).args[1];
+            // simulate track being muted
+            mutedListener({trackState: {muted: mute}});
+
+            await stableState();
+
+            // nothing should happen
+            assert.notCalled(locusMediaRequestStub);
+            assert.notCalled(fakeRoapMediaConnection.update);
+
+            // now simulate roap offer
+            await simulateRoapOffer();
+
+            // it should be sent with the right mute status
+            checkSdpOfferSent({audioMuted: mute, videoMuted: true});
+
+            // nothing else should happen
+            assert.calledOnce(locusMediaRequestStub);
+            assert.notCalled(fakeRoapMediaConnection.update);
+          })
+        );
+      }));
+
+      describe('#acknowledge', () => {
+        it('should have #acknowledge', () => {
+          assert.exists(meeting.acknowledge);
         });
+        beforeEach(() => {
+          meeting.meetingRequest.acknowledgeMeeting = sinon.stub().returns(Promise.resolve());
+        });
+        it('should acknowledge incoming and return a promise', async () => {
+          const ack = meeting.acknowledge('INCOMING', false);
 
-        // eslint-disable-next-line max-len
-        it('will use shareConstraints if defined in provided options', () => {
-          const SHARE_WIDTH = 640;
-          const SHARE_HEIGHT = 480;
-          const shareConstraints = {
-            highFrameRate: 2,
-            maxWidth: SHARE_WIDTH,
-            maxHeight: SHARE_HEIGHT,
-            idealWidth: SHARE_WIDTH,
-            idealHeight: SHARE_HEIGHT,
-          };
+          assert.exists(ack.then);
+          await ack;
+          assert.calledOnce(meeting.meetingRequest.acknowledgeMeeting);
+        });
+        it('should acknowledge a non incoming and return a promise', async () => {
+          const ack = meeting.acknowledge(test1, false);
 
-          // If sharePreferences.shareConstraints is defined it ignores
-          // default SDK config settings
-          getDisplayMedia(
-            {
-              ...shareOptions,
-              sharePreferences: {shareConstraints},
-            },
-            config
-          );
+          assert.exists(ack.then);
+          await ack;
+          assert.notCalled(meeting.meetingRequest.acknowledgeMeeting);
+        });
+      });
+      describe('#decline', () => {
+        it('should have #decline', () => {
+          assert.exists(meeting.decline);
+        });
+        beforeEach(() => {
+          meeting.meetingRequest.declineMeeting = sinon.stub().returns(Promise.resolve());
+          meeting.meetingFiniteStateMachine.ring();
+        });
+        it('should decline the meeting and trigger meeting destroy for 1:1', async () => {
+          await meeting.decline();
+          assert.calledOnce(meeting.meetingRequest.declineMeeting);
+        });
+      });
+      describe('#leave', () => {
+        let sandbox;
 
-          // eslint-disable-next-line no-undef
-          assert.calledWith(
-            navigator.mediaDevices.getDisplayMedia,
-            browserConditionalValue({
-              default: {
-                video: {...shareConstraints},
-              },
-              // Firefox is being handled differently
-              firefox: fireFoxOptions,
-            })
-          );
+        it('should have #leave', () => {
+          assert.exists(meeting.leave);
         });
 
-        // eslint-disable-next-line max-len
-        it('will use default resolution if shareConstraints is undefined and highFrameRate is defined', () => {
-          // If highFrameRate is defined it ignores default SDK config settings
-          getDisplayMedia(
-            {
-              ...shareOptions,
-              sharePreferences: {
-                highFrameRate: true,
-              },
-            },
-            config
-          );
+        it('should reject if meeting is already inactive', async () => {
+          await meeting.leave().catch((err) => {
+            assert.instanceOf(err, MeetingNotActiveError);
+          });
+        });
 
-          // eslint-disable-next-line no-undef
-          assert.calledWith(
-            navigator.mediaDevices.getDisplayMedia,
-            browserConditionalValue({
-              default: {
-                video: {
-                  ...MediaConstraint,
-                  frameRate: config.videoShareFrameRate,
-                  width: resolution.idealWidth,
-                  height: resolution.idealHeight,
-                  maxWidth: resolution.maxWidth,
-                  maxHeight: resolution.maxHeight,
-                  idealWidth: resolution.idealWidth,
-                  idealHeight: resolution.idealHeight,
-                },
-              },
-              firefox: fireFoxOptions,
-            })
-          );
+        it('should reject if meeting is already left', async () => {
+          meeting.meetingState = 'ACTIVE';
+          await meeting.leave().catch((err) => {
+            assert.instanceOf(err, UserNotJoinedError);
+          });
         });
 
-        // eslint-disable-next-line max-len
-        it('will use default screenResolution if shareConstraints, highFrameRate, and SDK defaults is undefined', () => {
-          getDisplayMedia(shareOptions);
-          const {screenResolution} = config;
+        beforeEach(() => {
+          sandbox = sinon.createSandbox();
+          meeting.meetingFiniteStateMachine.ring();
+          meeting.meetingFiniteStateMachine.join();
+          meeting.meetingRequest.leaveMeeting = sinon
+            .stub()
+            .returns(Promise.resolve({body: 'test'}));
+          meeting.locusInfo.onFullLocus = sinon.stub().returns(true);
+          meeting.cleanupLocalTracks = sinon.stub().returns(Promise.resolve());
+          meeting.closeRemoteStream = sinon.stub().returns(Promise.resolve());
+          sandbox.stub(meeting, 'closeRemoteTracks').returns(Promise.resolve());
+          meeting.closePeerConnections = sinon.stub().returns(Promise.resolve());
+          meeting.unsetRemoteTracks = sinon.stub();
+          meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
+          meeting.unsetPeerConnections = sinon.stub().returns(true);
+          meeting.logger.error = sinon.stub().returns(true);
+          meeting.updateLLMConnection = sinon.stub().returns(Promise.resolve());
+
+          // A meeting needs to be joined to leave
+          meeting.meetingState = 'ACTIVE';
+          meeting.state = 'JOINED';
+        });
+        afterEach(() => {
+          sandbox.restore();
+          sandbox = null;
+        });
+        it('should leave the meeting and return promise', async () => {
+          const leave = meeting.leave();
 
-          // eslint-disable-next-line no-undef
-          assert.calledWith(
-            navigator.mediaDevices.getDisplayMedia,
-            browserConditionalValue({
-              default: {
-                video: {
-                  ...MediaConstraint,
-                  width: screenResolution.idealWidth,
-                  height: screenResolution.idealHeight,
-                },
-              },
-              firefox: fireFoxOptions,
-            })
-          );
+          assert.exists(leave.then);
+          await leave;
+          assert.calledOnce(meeting.meetingRequest.leaveMeeting);
+          assert.calledOnce(meeting.cleanupLocalTracks);
+          assert.calledOnce(meeting.closeRemoteTracks);
+          assert.calledOnce(meeting.closePeerConnections);
+          assert.calledOnce(meeting.unsetRemoteTracks);
+          assert.calledOnce(meeting.unsetPeerConnections);
         });
+        describe('after audio/video is defined', () => {
+          let handleClientRequest;
 
-        // Test screenResolution
-        // eslint-disable-next-line max-len
-        it('will use SDK config screenResolution if set, with shareConstraints and highFrameRate being undefined', () => {
-          const SHARE_WIDTH = 800;
-          const SHARE_HEIGHT = 600;
-          const customConfig = {
-            screenResolution: {
-              maxWidth: SHARE_WIDTH,
-              maxHeight: SHARE_HEIGHT,
-              idealWidth: SHARE_WIDTH,
-              idealHeight: SHARE_HEIGHT,
-            },
-          };
+          beforeEach(() => {
+            handleClientRequest = sinon.stub().returns(Promise.resolve(true));
 
-          getDisplayMedia(shareOptions, customConfig);
+            meeting.audio = {handleClientRequest};
+            meeting.video = {handleClientRequest};
+          });
 
-          // eslint-disable-next-line no-undef
-          assert.calledWith(
-            navigator.mediaDevices.getDisplayMedia,
-            browserConditionalValue({
-              default: {
-                video: {
-                  ...MediaConstraint,
-                  width: SHARE_WIDTH,
-                  height: SHARE_HEIGHT,
-                  maxWidth: SHARE_WIDTH,
-                  maxHeight: SHARE_HEIGHT,
-                  idealWidth: SHARE_WIDTH,
-                  idealHeight: SHARE_HEIGHT,
-                },
-              },
-              firefox: fireFoxOptions,
-            })
-          );
+          it('should delete audio and video state machines when leaving the meeting', async () => {
+            const leave = meeting.leave();
+
+            assert.exists(leave.then);
+            await leave;
+
+            assert.isNull(meeting.audio);
+            assert.isNull(meeting.video);
+          });
         });
+        it('should leave the meeting without leaving resource', async () => {
+          const leave = meeting.leave({resourceId: null});
 
-        // Test screenFrameRate
-        it('will use SDK config screenFrameRate if set, with shareConstraints and highFrameRate being undefined', () => {
-          const SHARE_WIDTH = 800;
-          const SHARE_HEIGHT = 600;
-          const customConfig = {
-            screenFrameRate: 999,
-            screenResolution: {
-              maxWidth: SHARE_WIDTH,
-              maxHeight: SHARE_HEIGHT,
-              idealWidth: SHARE_WIDTH,
-              idealHeight: SHARE_HEIGHT,
-            },
-          };
+          assert.exists(leave.then);
+          await leave;
+          assert.calledWith(meeting.meetingRequest.leaveMeeting, {
+            locusUrl: meeting.locusUrl,
+            correlationId: meeting.correlationId,
+            selfId: meeting.selfId,
+            resourceId: null,
+            deviceUrl: meeting.deviceUrl,
+          });
+        });
+        it('should leave the meeting on the resource', async () => {
+          const leave = meeting.leave();
 
-          getDisplayMedia(shareOptions, customConfig);
+          assert.exists(leave.then);
+          await leave;
+          assert.calledWith(meeting.meetingRequest.leaveMeeting, {
+            locusUrl: meeting.locusUrl,
+            correlationId: meeting.correlationId,
+            selfId: meeting.selfId,
+            resourceId: meeting.resourceId,
+            deviceUrl: meeting.deviceUrl
+          });
+        });
+        it('should leave the meeting on the resource with reason', async () => {
+          const leave = meeting.leave({resourceId: meeting.resourceId, reason: MEETING_REMOVED_REASON.CLIENT_LEAVE_REQUEST});
 
-          // eslint-disable-next-line no-undef
-          assert.calledWith(
-            navigator.mediaDevices.getDisplayMedia,
-            browserConditionalValue({
-              default: {
-                video: {
-                  ...MediaConstraint,
-                  frameRate: customConfig.screenFrameRate,
-                  width: SHARE_WIDTH,
-                  height: SHARE_HEIGHT,
-                  maxWidth: SHARE_WIDTH,
-                  maxHeight: SHARE_HEIGHT,
-                  idealWidth: SHARE_WIDTH,
-                  idealHeight: SHARE_HEIGHT,
-                },
-              },
-              firefox: fireFoxOptions,
-            })
-          );
+          assert.exists(leave.then);
+          await leave;
+          assert.calledWith(meeting.meetingRequest.leaveMeeting, {
+            locusUrl: meeting.locusUrl,
+            correlationId: meeting.correlationId,
+            selfId: meeting.selfId,
+            resourceId: meeting.resourceId,
+            deviceUrl: meeting.deviceUrl,
+            reason: MEETING_REMOVED_REASON.CLIENT_LEAVE_REQUEST
+          });
         });
       });
-
-      describe('#stopShare', () => {
-        it('should have #stopShare', () => {
-          assert.exists(meeting.stopShare);
+      describe('#requestScreenShareFloor', () => {
+        it('should have #requestScreenShareFloor', () => {
+          assert.exists(meeting.requestScreenShareFloor);
         });
         beforeEach(() => {
-          meeting.mediaProperties.mediaDirection = {receiveShare: true};
-          meeting.updateShare = sinon.stub().returns(Promise.resolve());
+          meeting.locusInfo.mediaShares = [{name: 'content', url: url1}];
+          meeting.locusInfo.self = {url: url1};
+          meeting.meetingRequest.changeMeetingFloor = sinon.stub().returns(Promise.resolve());
+          meeting.mediaProperties.shareTrack = {}
+          meeting.mediaProperties.mediaDirection.sendShare = true;
+          meeting.state = 'JOINED';
         });
-        it('should call updateShare', async () => {
-          const share = meeting.stopShare();
+        it('should send the share', async () => {
+          const share = meeting.requestScreenShareFloor();
 
           assert.exists(share.then);
           await share;
-          assert.calledOnce(meeting.updateShare);
-        });
-      });
-
-      describe('#updateAudio', () => {
-        const FAKE_AUDIO_TRACK = {
-          id: 'fake audio track',
-          getSettings: sinon.stub().returns({}),
-        };
-
-        describe('when canUpdateMedia is true', () => {
-          beforeEach(() => {
-            meeting.canUpdateMedia = sinon.stub().returns(true);
-          });
-          describe('when options are valid', () => {
-            beforeEach(() => {
-              MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve());
-              meeting.mediaProperties.mediaDirection = {
-                sendAudio: false,
-                sendVideo: true,
-                sendShare: false,
-                receiveAudio: false,
-                receiveVideo: true,
-                receiveShare: true,
-              };
-              meeting.mediaProperties.webrtcMediaConnection = {
-                updateSendReceiveOptions: sinon.stub(),
-              };
-              sinon.stub(MeetingUtil, 'getTrack').returns({audioTrack: FAKE_AUDIO_TRACK});
-            });
-            it('calls this.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions', () =>
-              meeting
-                .updateAudio({
-                  sendAudio: true,
-                  receiveAudio: true,
-                  stream: {id: 'fake stream'},
-                })
-                .then(() => {
-                  assert.calledOnce(
-                    meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions
-                  );
-                  assert.calledWith(
-                    meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions,
-                    {
-                      send: {audio: FAKE_AUDIO_TRACK},
-                      receive: {
-                        audio: true,
-                        video: true,
-                        screenShareVideo: true,
-                        remoteQualityLevel: 'HIGH',
-                      },
-                    }
-                  );
-                }));
-          });
-          afterEach(() => {
-            sinon.restore();
-          });
+          assert.calledOnce(meeting.meetingRequest.changeMeetingFloor);
         });
       });
 
@@ -2034,37 +2227,25 @@ describe('plugin-meetings', () => {
 
       describe('#updateMedia', () => {
         let sandbox;
-        const mockLocalStream = {id: 'mock local stream'};
-        const mockLocalShare = {id: 'mock local share stream'};
-        const FAKE_TRACKS = {
-          audio: {
-            id: 'fake audio track',
-            getSettings: sinon.stub().returns({}),
-          },
-          video: {
-            id: 'fake video track',
-            getSettings: sinon.stub().returns({}),
-          },
-          screenshareVideo: {
-            id: 'fake share track',
-            getSettings: sinon.stub().returns({}),
-          },
-        };
 
+        const createFakeLocalTrack = () => ({
+          underlyingTrack: {id: 'fake underlying track'}
+        });
         beforeEach(() => {
           sandbox = sinon.createSandbox();
-          meeting.mediaProperties.mediaDirection = {sendShare: true};
-          // setup the stub to return the right tracks
-          sandbox.stub(MeetingUtil, 'getTrack').callsFake((stream) => {
-            if (stream === mockLocalStream) {
-              return {audioTrack: FAKE_TRACKS.audio, videoTrack: FAKE_TRACKS.video};
-            }
-            if (stream === mockLocalShare) {
-              return {audioTrack: null, videoTrack: FAKE_TRACKS.screenshareVideo};
-            }
-
-            return {audioTrack: null, videoTrack: null};
-          });
+          meeting.audio = { enable: sinon.stub()};
+          meeting.video = { enable: sinon.stub()};
+          meeting.mediaProperties.audioTrack = createFakeLocalTrack();
+          meeting.mediaProperties.videoTrack = createFakeLocalTrack();
+          meeting.mediaProperties.shareTrack = createFakeLocalTrack();
+          meeting.mediaProperties.mediaDirection = {
+            sendAudio: true,
+            sendVideo: true,
+            sendShare: true,
+            receiveAudio: true,
+            receiveVideo: true,
+            receiveShare: true,
+          }
         });
 
         afterEach(() => {
@@ -2072,36 +2253,45 @@ describe('plugin-meetings', () => {
           sandbox = null;
         });
 
-        it('should use a queue if currently busy', async () => {
-          const mediaSettings = {
-            sendAudio: true,
-            receiveAudio: true,
-            sendVideo: true,
-            receiveVideo: true,
-            sendShare: true,
-            receiveShare: true,
-            isSharing: true,
-          };
+        forEach(
+          [
+            {audioEnabled: true, enableMultistreamAudio: true},
+            {audioEnabled: false, enableMultistreamAudio: false},
+          ],
+          ({audioEnabled, enableMultistreamAudio}) => {
+            it(`should call enableMultistreamAudio with ${enableMultistreamAudio} if it is a multistream connection and audioEnabled: ${audioEnabled}`, async () => {
+              meeting.mediaProperties.webrtcMediaConnection = {
+                enableMultistreamAudio: sinon.stub().resolves({}),
+              };
+              meeting.isMultistream = true;
+
+              await meeting.updateMedia({audioEnabled});
+
+              assert.calledOnceWithExactly(
+                meeting.mediaProperties.webrtcMediaConnection.enableMultistreamAudio,
+                enableMultistreamAudio
+              );
+              assert.calledOnceWithExactly(meeting.audio.enable, meeting, enableMultistreamAudio);
+            });
+          }
+        );
 
+        it('should use a queue if currently busy', async () => {
           sandbox.stub(meeting, 'canUpdateMedia').returns(false);
           meeting.mediaProperties.webrtcMediaConnection = {
-            updateSendReceiveOptions: sinon.stub().resolves({}),
+            update: sinon.stub().resolves({}),
           };
 
           let myPromiseResolved = false;
 
           meeting
-            .updateMedia({
-              localStream: mockLocalStream,
-              localShare: mockLocalShare,
-              mediaSettings,
-            })
+            .updateMedia({audioEnabled: false, videoEnabled: false})
             .then(() => {
               myPromiseResolved = true;
             });
 
           // verify that nothing was done
-          assert.notCalled(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+          assert.notCalled(meeting.mediaProperties.webrtcMediaConnection.update);
 
           // now trigger processing of the queue
           meeting.canUpdateMedia.restore();
@@ -2110,22 +2300,22 @@ describe('plugin-meetings', () => {
           meeting.processNextQueuedMediaUpdate();
           await testUtils.flushPromises();
 
-          // and check that updateSendReceiveOptions is called with the original args
-          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+          // and check that update is called with the original args
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.update);
           assert.calledWith(
-            meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions,
+            meeting.mediaProperties.webrtcMediaConnection.update,
             {
-              send: {
-                audio: FAKE_TRACKS.audio,
-                video: FAKE_TRACKS.video,
-                screenShareVideo: FAKE_TRACKS.screenshareVideo,
+              localTracks: {
+                audio: meeting.mediaProperties.audioTrack.underlyingTrack,
+                video: meeting.mediaProperties.videoTrack.underlyingTrack,
+                screenShareVideo: meeting.mediaProperties.shareTrack.underlyingTrack,
               },
-              receive: {
-                audio: true,
-                video: true,
-                screenShareVideo: true,
-                remoteQualityLevel: 'HIGH',
+              direction: {
+                audio: 'inactive',
+                video: 'inactive',
+                screenShareVideo: 'sendrecv',
               },
+              remoteQualityLevel: 'HIGH',
             }
           );
           assert.isTrue(myPromiseResolved);
@@ -2144,8 +2334,6 @@ describe('plugin-meetings', () => {
               sendShare: false,
               receiveVideo: true,
             };
-            meeting.getMediaStreams = sinon.stub().returns(Promise.resolve([]));
-            meeting.updateVideo = sinon.stub().returns(Promise.resolve());
             meeting.mediaProperties.mediaDirection = mediaDirection;
             meeting.mediaProperties.remoteVideoTrack = sinon
               .stub()
@@ -2382,76 +2570,12 @@ describe('plugin-meetings', () => {
         });
       });
 
-      describe('#setLocalVideoQuality', () => {
-        let mediaDirection;
-
-        const fakeTrack = {getSettings: () => ({height: 720})};
-        const USER_AGENT_CHROME_MAC =
-          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) ' +
-          'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36';
-
-        beforeEach(() => {
-          mediaDirection = {sendAudio: true, sendVideo: true, sendShare: false};
-          meeting.getMediaStreams = sinon.stub().returns(Promise.resolve([]));
-          meeting.mediaProperties.mediaDirection = mediaDirection;
-          meeting.canUpdateMedia = sinon.stub().returns(true);
-          MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve());
-          meeting.updateVideo = sinon.stub().resolves();
-          sinon.stub(MeetingUtil, 'getTrack').returns({videoTrack: fakeTrack});
-        });
-
-        it('should have #setLocalVideoQuality', () => {
-          assert.exists(meeting.setLocalVideoQuality);
-        });
-
-        it('should call getMediaStreams with the proper level', () =>
-          meeting.setLocalVideoQuality(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
-            delete mediaDirection.receiveVideo;
-            assert.calledWith(
-              meeting.getMediaStreams,
-              mediaDirection,
-              CONSTANTS.VIDEO_RESOLUTIONS[CONSTANTS.QUALITY_LEVELS.LOW]
-            );
-          }));
-
-        it('when browser is chrome then it should stop previous video track', () => {
-          meeting.mediaProperties.videoTrack = fakeTrack;
-          assert.equal(BrowserDetection(USER_AGENT_CHROME_MAC).getBrowserName(), 'Chrome');
-          meeting.setLocalVideoQuality(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
-            assert.calledWith(Media.stopTracks, fakeTrack);
-          });
-        });
-
-        it('should set mediaProperty with the proper level', () =>
-          meeting.setLocalVideoQuality(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
-            assert.equal(meeting.mediaProperties.localQualityLevel, CONSTANTS.QUALITY_LEVELS.LOW);
-          }));
-
-        it('when device does not support 1080p then it should set localQualityLevel with highest possible resolution', () => {
-          meeting.setLocalVideoQuality(CONSTANTS.QUALITY_LEVELS['1080p']).then(() => {
-            assert.equal(
-              meeting.mediaProperties.localQualityLevel,
-              CONSTANTS.QUALITY_LEVELS['720p']
-            );
-          });
-        });
-
-        it('should error if set to a invalid level', () => {
-          assert.isRejected(meeting.setLocalVideoQuality('invalid'));
-        });
-
-        it('should error if sendVideo is set to false', () => {
-          meeting.mediaProperties.mediaDirection = {sendVideo: false};
-          assert.isRejected(meeting.setLocalVideoQuality('LOW'));
-        });
-      });
-
       describe('#setRemoteQualityLevel', () => {
         let mediaDirection;
 
         beforeEach(() => {
           mediaDirection = {receiveAudio: true, receiveVideo: true, receiveShare: false};
-          meeting.updateMedia = sinon.stub().returns(Promise.resolve());
+          meeting.updateTranscodedMediaConnection = sinon.stub().returns(Promise.resolve());
           meeting.mediaProperties.mediaDirection = mediaDirection;
         });
 
@@ -2464,9 +2588,9 @@ describe('plugin-meetings', () => {
             assert.equal(meeting.mediaProperties.remoteQualityLevel, CONSTANTS.QUALITY_LEVELS.LOW);
           }));
 
-        it('should call updateMedia', () =>
+        it('should call Meeting.updateTranscodedMediaConnection()', () =>
           meeting.setRemoteQualityLevel(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
-            assert.calledOnce(meeting.updateMedia);
+            assert.calledOnce(meeting.updateTranscodedMediaConnection);
           }));
 
         it('should error if set to a invalid level', () => {
@@ -2487,7 +2611,6 @@ describe('plugin-meetings', () => {
           meeting.meetingRequest.dialOut = sinon
             .stub()
             .returns(Promise.resolve({body: {locus: 'testData'}}));
-          meeting.locusInfo.onFullLocus = sinon.stub().returns(Promise.resolve());
         });
 
         it('with no parameters triggers dial-in, delegating request to meetingRequest correctly', async () => {
@@ -2500,11 +2623,9 @@ describe('plugin-meetings', () => {
             locusUrl: meeting.locusUrl,
             clientUrl: meeting.deviceUrl,
           });
-          assert.calledWith(meeting.locusInfo.onFullLocus, 'testData');
           assert.notCalled(meeting.meetingRequest.dialOut);
 
           meeting.meetingRequest.dialIn.resetHistory();
-          meeting.locusInfo.onFullLocus.resetHistory();
 
           // try again. the dial in urls should match
           await meeting.usePhoneAudio();
@@ -2515,7 +2636,6 @@ describe('plugin-meetings', () => {
             locusUrl: meeting.locusUrl,
             clientUrl: meeting.deviceUrl,
           });
-          assert.calledWith(meeting.locusInfo.onFullLocus, 'testData');
           assert.notCalled(meeting.meetingRequest.dialOut);
         });
 
@@ -2532,11 +2652,9 @@ describe('plugin-meetings', () => {
             clientUrl: meeting.deviceUrl,
             phoneNumber,
           });
-          assert.calledWith(meeting.locusInfo.onFullLocus, 'testData');
           assert.notCalled(meeting.meetingRequest.dialIn);
 
           meeting.meetingRequest.dialOut.resetHistory();
-          meeting.locusInfo.onFullLocus.resetHistory();
 
           // try again. the dial out urls should match
           await meeting.usePhoneAudio(phoneNumber);
@@ -2548,7 +2666,6 @@ describe('plugin-meetings', () => {
             clientUrl: meeting.deviceUrl,
             phoneNumber,
           });
-          assert.calledWith(meeting.locusInfo.onFullLocus, 'testData');
           assert.notCalled(meeting.meetingRequest.dialIn);
         });
 
@@ -2593,6 +2710,9 @@ describe('plugin-meetings', () => {
         const FAKE_CAPTCHA_IMAGE_URL = 'http://captchaimage';
         const FAKE_CAPTCHA_AUDIO_URL = 'http://captchaaudio';
         const FAKE_CAPTCHA_REFRESH_URL = 'http://captcharefresh';
+        const FAKE_INSTALLED_ORG_ID = '123456';
+        const FAKE_EXTRA_PARAMS = {mtid: 'm9fe0afd8c435e892afcce9ea25b97046', joinTXId: 'TSmrX61wNF'};
+        let FAKE_OPTIONS;
         const FAKE_MEETING_INFO = {
           conversationUrl: 'some_convo_url',
           locusUrl: 'some_locus_url',
@@ -2600,6 +2720,8 @@ describe('plugin-meetings', () => {
           meetingNumber: '123456', // this.config.experimental.enableUnifiedMeetings
           hostId: 'some_host_id', // this.owner;
         };
+        const FAKE_MEETING_INFO_LOOKUP_URL = 'meetingLookupUrl';
+
         const FAKE_SDK_CAPTCHA_INFO = {
           captchaId: FAKE_CAPTCHA_ID,
           verificationImageURL: FAKE_CAPTCHA_IMAGE_URL,
@@ -2613,18 +2735,26 @@ describe('plugin-meetings', () => {
           refreshURL: `${FAKE_CAPTCHA_REFRESH_URL}-2`,
         };
 
+        beforeEach(() => {
+          meeting.locusId = 'locus-id';
+          meeting.id = 'meeting-id';
+          FAKE_OPTIONS = {meetingId: meeting.id};
+        });
+
         it('calls meetingInfoProvider with all the right parameters and parses the result', async () => {
           meeting.attrs.meetingInfoProvider = {
-            fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO}),
+            fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO, url: FAKE_MEETING_INFO_LOOKUP_URL}),
           };
           meeting.requiredCaptcha = FAKE_SDK_CAPTCHA_INFO;
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
+          meeting.config.installedOrgID = FAKE_INSTALLED_ORG_ID;
           meeting.parseMeetingInfo = sinon.stub().returns(undefined);
 
           await meeting.fetchMeetingInfo({
             password: FAKE_PASSWORD,
             captchaCode: FAKE_CAPTCHA_CODE,
+            extraParams: FAKE_EXTRA_PARAMS,
           });
 
           assert.calledWith(
@@ -2632,11 +2762,15 @@ describe('plugin-meetings', () => {
             FAKE_DESTINATION,
             FAKE_TYPE,
             FAKE_PASSWORD,
-            {code: FAKE_CAPTCHA_CODE, id: FAKE_CAPTCHA_ID}
+            {code: FAKE_CAPTCHA_CODE, id: FAKE_CAPTCHA_ID},
+            FAKE_INSTALLED_ORG_ID,
+            meeting.locusId,
+            FAKE_EXTRA_PARAMS,
+            FAKE_OPTIONS
           );
 
-          assert.calledWith(meeting.parseMeetingInfo, {body: FAKE_MEETING_INFO}, FAKE_DESTINATION);
-          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.calledWith(meeting.parseMeetingInfo, {body: FAKE_MEETING_INFO, url: FAKE_MEETING_INFO_LOOKUP_URL}, FAKE_DESTINATION);
+          assert.deepEqual(meeting.meetingInfo, {...FAKE_MEETING_INFO, meetingLookupUrl: FAKE_MEETING_INFO_LOOKUP_URL});
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.NOT_REQUIRED);
           assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
           assert.equal(meeting.requiredCaptcha, null);
@@ -2651,7 +2785,7 @@ describe('plugin-meetings', () => {
 
         it('calls meetingInfoProvider with all the right parameters and parses the result when random delay is applied', async () => {
           meeting.attrs.meetingInfoProvider = {
-            fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO}),
+            fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO, url: FAKE_MEETING_INFO_LOOKUP_URL}),
           };
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
@@ -2674,13 +2808,17 @@ describe('plugin-meetings', () => {
             FAKE_DESTINATION,
             FAKE_TYPE,
             null,
-            null
+            null,
+            undefined,
+            meeting.locusId,
+            {},
+            {meetingId: meeting.id}
           );
 
           // parseMeeting info
-          assert.calledWith(meeting.parseMeetingInfo, {body: FAKE_MEETING_INFO}, FAKE_DESTINATION);
+          assert.calledWith(meeting.parseMeetingInfo, {body: FAKE_MEETING_INFO, url: FAKE_MEETING_INFO_LOOKUP_URL}, FAKE_DESTINATION);
 
-          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.deepEqual(meeting.meetingInfo, {...FAKE_MEETING_INFO, meetingLookupUrl: FAKE_MEETING_INFO_LOOKUP_URL});
           assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
           assert.equal(meeting.requiredCaptcha, null);
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.NOT_REQUIRED);
@@ -2696,7 +2834,7 @@ describe('plugin-meetings', () => {
 
         it('fails if captchaCode is provided when captcha not needed', async () => {
           meeting.attrs.meetingInfoProvider = {
-            fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO}),
+            fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO, url: FAKE_MEETING_INFO_LOOKUP_URL}),
           };
           meeting.requiredCaptcha = null;
           meeting.destination = FAKE_DESTINATION;
@@ -2715,7 +2853,7 @@ describe('plugin-meetings', () => {
 
         it('fails if password is provided when not required', async () => {
           meeting.attrs.meetingInfoProvider = {
-            fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO}),
+            fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO, url: FAKE_MEETING_INFO_LOOKUP_URL}),
           };
           meeting.passwordStatus = PASSWORD_STATUS.NOT_REQUIRED;
           meeting.destination = FAKE_DESTINATION;
@@ -2748,10 +2886,15 @@ describe('plugin-meetings', () => {
             FAKE_DESTINATION,
             FAKE_TYPE,
             null,
-            null
+            null,
+            undefined,
+            'locus-id',
+            {},
+            {meetingId: meeting.id},
           );
 
           assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(meeting.meetingInfoFailureCode, 403004);
           assert.equal(
             meeting.meetingInfoFailureReason,
             MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD
@@ -2760,6 +2903,38 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
         });
 
+        it('handles meetingInfoProvider policy error', async () => {
+          meeting.destination = FAKE_DESTINATION;
+          meeting.destinationType = FAKE_TYPE;
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon
+              .stub()
+              .throws(new MeetingInfoV2PolicyError(123456, FAKE_MEETING_INFO, 'a message')),
+          };
+
+          await assert.isRejected(meeting.fetchMeetingInfo({}), PermissionError);
+
+          assert.calledWith(
+            meeting.attrs.meetingInfoProvider.fetchMeetingInfo,
+            FAKE_DESTINATION,
+            FAKE_TYPE,
+            null,
+            null,
+            undefined,
+            'locus-id',
+            {},
+            {meetingId: meeting.id},
+          );
+
+          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(meeting.meetingInfoFailureCode, 123456);
+          assert.equal(
+            meeting.meetingInfoFailureReason,
+            MEETING_INFO_FAILURE_REASON.POLICY
+          );
+        });
+
+
         it('handles meetingInfoProvider requiring captcha because of wrong password', async () => {
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
@@ -2782,7 +2957,11 @@ describe('plugin-meetings', () => {
             FAKE_DESTINATION,
             FAKE_TYPE,
             'aaa',
-            null
+            null,
+            undefined,
+            'locus-id',
+            {},
+            {meetingId: meeting.id},
           );
 
           assert.deepEqual(meeting.meetingInfo, {});
@@ -2790,6 +2969,7 @@ describe('plugin-meetings', () => {
             meeting.meetingInfoFailureReason,
             MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD
           );
+            assert.equal(meeting.meetingInfoFailureCode, 423005);
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
           assert.deepEqual(meeting.requiredCaptcha, {
             captchaId: FAKE_CAPTCHA_ID,
@@ -2822,7 +3002,11 @@ describe('plugin-meetings', () => {
             FAKE_DESTINATION,
             FAKE_TYPE,
             'aaa',
-            {code: 'bbb', id: FAKE_CAPTCHA_ID}
+            {code: 'bbb', id: FAKE_CAPTCHA_ID},
+            undefined,
+            'locus-id',
+            {},
+            {meetingId: meeting.id}
           );
 
           assert.deepEqual(meeting.meetingInfo, {});
@@ -2851,10 +3035,14 @@ describe('plugin-meetings', () => {
             FAKE_DESTINATION,
             FAKE_TYPE,
             'aaa',
-            null
+            null,
+            undefined,
+            'locus-id',
+            {},
+            {meetingId: meeting.id},
           );
 
-          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.deepEqual(meeting.meetingInfo, {...FAKE_MEETING_INFO, meetingLookupUrl: undefined});
           assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.VERIFIED);
           assert.equal(meeting.requiredCaptcha, null);
@@ -2896,7 +3084,11 @@ describe('plugin-meetings', () => {
             FAKE_DESTINATION,
             FAKE_TYPE,
             'aaa',
-            {code: 'bbb', id: FAKE_CAPTCHA_ID}
+            {code: 'bbb', id: FAKE_CAPTCHA_ID},
+            undefined,
+            'locus-id',
+            {},
+            {meetingId: meeting.id},
           );
 
           assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
@@ -3041,6 +3233,17 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('#postMetrics', () => {
+        it('should have #postMetrics', () => {
+          assert.exists(meeting.postMetrics);
+        });
+
+        it('should trigger `postMetrics`', async () => {
+          await meeting.postMetrics(eventType.LEAVE);
+          assert.calledWithMatch(Metrics.postEvent, {event: eventType.LEAVE});
+        });
+      });
+
       describe('#endMeeting for all', () => {
         let sandbox;
 
@@ -3061,16 +3264,12 @@ describe('plugin-meetings', () => {
             .stub()
             .returns(Promise.resolve({body: 'test'}));
           meeting.locusInfo.onFullLocus = sinon.stub().returns(true);
-          meeting.closeLocalStream = sinon.stub().returns(Promise.resolve());
-          meeting.closeLocalShare = sinon.stub().returns(Promise.resolve());
+          meeting.cleanupLocalTracks = sinon.stub().returns(Promise.resolve());
           meeting.closeRemoteStream = sinon.stub().returns(Promise.resolve());
           sandbox.stub(meeting, 'closeRemoteTracks').returns(Promise.resolve());
           meeting.closePeerConnections = sinon.stub().returns(Promise.resolve());
-          meeting.unsetLocalVideoTrack = sinon.stub().returns(true);
-          meeting.unsetLocalShareTrack = sinon.stub().returns(true);
           meeting.unsetRemoteTracks = sinon.stub();
           meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
-          meeting.unsetRemoteStream = sinon.stub().returns(true);
           meeting.unsetPeerConnections = sinon.stub().returns(true);
           meeting.logger.error = sinon.stub().returns(true);
           meeting.updateLLMConnection = sinon.stub().returns(Promise.resolve());
@@ -3089,12 +3288,9 @@ describe('plugin-meetings', () => {
           assert.exists(endMeetingForAll.then);
           await endMeetingForAll;
           assert.calledOnce(meeting?.meetingRequest?.endMeetingForAll);
-          assert.calledOnce(meeting?.closeLocalStream);
-          assert.calledOnce(meeting?.closeLocalShare);
+          assert.calledOnce(meeting?.cleanupLocalTracks);
           assert.calledOnce(meeting?.closeRemoteTracks);
           assert.calledOnce(meeting?.closePeerConnections);
-          assert.calledOnce(meeting?.unsetLocalVideoTrack);
-          assert.calledOnce(meeting?.unsetLocalShareTrack);
           assert.calledOnce(meeting?.unsetRemoteTracks);
           assert.calledOnce(meeting?.unsetPeerConnections);
         });
@@ -3105,11 +3301,9 @@ describe('plugin-meetings', () => {
 
         beforeEach(() => {
           sandbox = sinon.createSandbox();
-          sandbox.stub(meeting, 'closeLocalStream');
-          sandbox.stub(meeting, 'closeLocalShare');
+          sandbox.stub(meeting, 'cleanupLocalTracks');
 
           sandbox.stub(meeting.mediaProperties, 'setMediaDirection');
-          sandbox.stub(meeting.mediaProperties, 'unsetMediaTracks');
 
           sandbox.stub(meeting.reconnectionManager, 'reconnectMedia').returns(Promise.resolve());
           sandbox
@@ -3182,14 +3376,12 @@ describe('plugin-meetings', () => {
 
           // beacuse we are calling callback so we need to wait
 
-          assert.called(meeting.closeLocalStream);
-          assert.called(meeting.closeLocalShare);
+          assert.called(meeting.cleanupLocalTracks);
 
           // give queued Promise callbacks a chance to run
           await Promise.resolve();
 
           assert.called(meeting.mediaProperties.setMediaDirection);
-          assert.called(meeting.mediaProperties.unsetMediaTracks);
 
           assert.calledWith(meeting.reconnectionManager.reconnectMedia, {
             mediaDirection: {
@@ -3268,41 +3460,319 @@ describe('plugin-meetings', () => {
           }
         });
 
-        it('should postEvent on moveFrom ', async () => {
-          await meeting.moveFrom('resourceId');
+        it('should postEvent on moveFrom ', async () => {
+          await meeting.moveFrom('resourceId');
+
+          assert.calledWithMatch(Metrics.postEvent, {event: eventType.MOVE_MEDIA});
+        });
+
+        it('should call `MeetingUtil.joinMeetingOptions` with resourceId', async () => {
+          sinon.spy(MeetingUtil, 'joinMeetingOptions');
+          await meeting.moveFrom('resourceId');
+
+          assert.calledWith(MeetingUtil.joinMeetingOptions, meeting);
+          assert.calledWith(MeetingUtil.leaveMeeting, meeting, {
+            resourceId: 'resourceId',
+            correlationId: meeting.correlationId,
+            moveMeeting: true,
+          });
+
+          assert.calledOnce(Metrics.sendBehavioralMetric);
+          assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.MOVE_FROM_SUCCESS);
+        });
+
+        it('should throw an error if moveFrom call fails', async () => {
+          MeetingUtil.joinMeeting = sinon.stub().returns(Promise.reject());
+          try {
+            await meeting.moveFrom('resourceId');
+          } catch {
+            assert.calledOnce(Metrics.sendBehavioralMetric);
+            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.MOVE_FROM_FAILURE, {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: sinon.match.any,
+              stack: sinon.match.any,
+            });
+          }
+        });
+      });
+      describe('Local tracks publishing', () => {
+        let audioTrack;
+        let videoTrack;
+        let videoShareTrack;
+        let createMuteStateStub;
+        let LocalDisplayTrackConstructorStub;
+        let LocalMicrophoneTrackConstructorStub;
+        let LocalCameraTrackConstructorStub;
+        let fakeLocalDisplayTrack;
+        let fakeLocalMicrophoneTrack;
+        let fakeLocalCameraTrack;
+
+        beforeEach(() => {
+          audioTrack = {
+            id: 'audio track',
+            getSettings: sinon.stub().returns({}),
+            on: sinon.stub(),
+            off: sinon.stub(),
+          };
+          videoTrack = {
+            id: 'video track',
+            getSettings: sinon.stub().returns({}),
+            on: sinon.stub(),
+            off: sinon.stub(),
+          };
+          videoShareTrack = {
+            id: 'share track',
+            on: sinon.stub(),
+            off: sinon.stub(),
+            getSettings: sinon.stub().returns({}),
+          };
+          meeting.requestScreenShareFloor = sinon.stub().resolves({});
+          meeting.releaseScreenShareFloor = sinon.stub().resolves({});
+          meeting.mediaProperties.mediaDirection = {
+            sendAudio: 'fake value', // using non-boolean here so that we can check that these values are untouched in tests
+            sendVideo: 'fake value',
+            sendShare: false,
+          };
+          meeting.isMultistream = true;
+          meeting.mediaProperties.webrtcMediaConnection = {
+            publishTrack: sinon.stub().resolves({}),
+            unpublishTrack: sinon.stub().resolves({}),
+          };
+          meeting.audio = { handleLocalTrackChange: sinon.stub()};
+          meeting.video = { handleLocalTrackChange: sinon.stub()};
+
+          const createFakeLocalTrack = (originalTrack) => ({
+            on: sinon.stub(),
+            off: sinon.stub(),
+            stop: sinon.stub(),
+            originalTrack,
+          });
+
+          // setup mock constructors for webrtc-core local track classes in such a way
+          // that they return the original track correctly (this is needed for unpublish() API tests)
+          LocalDisplayTrackConstructorStub = sinon
+            .stub(InternalMediaCoreModule, 'LocalDisplayTrack')
+            .callsFake((stream) => {
+              fakeLocalDisplayTrack = createFakeLocalTrack(stream.getTracks()[0]);
+              return fakeLocalDisplayTrack;
+            });
+          LocalMicrophoneTrackConstructorStub = sinon
+            .stub(InternalMediaCoreModule, 'LocalMicrophoneTrack')
+            .callsFake((stream) => {
+              fakeLocalMicrophoneTrack = createFakeLocalTrack(stream.getTracks()[0]);
+              return fakeLocalMicrophoneTrack;
+            });
+          LocalCameraTrackConstructorStub = sinon
+            .stub(InternalMediaCoreModule, 'LocalCameraTrack')
+            .callsFake((stream) => {
+              fakeLocalCameraTrack = createFakeLocalTrack(stream.getTracks()[0]);
+              return fakeLocalCameraTrack;
+            });
+
+          createMuteStateStub = sinon
+            .stub(MuteStateModule, 'createMuteState')
+            .returns({id: 'fake mute state instance'});
+        });
+        describe('#publishTracks', () => {
+          it('fails if there is no media connection', async () => {
+            meeting.mediaProperties.webrtcMediaConnection = undefined;
+            await assert.isRejected(meeting.publishTracks({audio: {id: 'some audio track'}}));
+          });
+
+          const checkAudioPublished = (track) => {
+            assert.calledOnceWithExactly(meeting.audio.handleLocalTrackChange, meeting);
+            assert.calledWith(
+              meeting.mediaProperties.webrtcMediaConnection.publishTrack,
+              track
+            );
+            assert.equal(meeting.mediaProperties.audioTrack, track);
+            // check that sendAudio hasn't been touched
+            assert.equal(meeting.mediaProperties.mediaDirection.sendAudio, 'fake value');
+          };
+
+          const checkVideoPublished = (track) => {
+            assert.calledOnceWithExactly(meeting.video.handleLocalTrackChange, meeting);
+            assert.calledWith(
+              meeting.mediaProperties.webrtcMediaConnection.publishTrack,
+              track
+            );
+            assert.equal(meeting.mediaProperties.videoTrack, track);
+            // check that sendVideo hasn't been touched
+            assert.equal(meeting.mediaProperties.mediaDirection.sendVideo, 'fake value');
+          };
+
+          const checkScreenShareVideoPublished = (track) => {
+            assert.calledOnce(meeting.requestScreenShareFloor);
+
+            assert.calledWith(
+              meeting.mediaProperties.webrtcMediaConnection.publishTrack,
+              track
+            );
+            assert.equal(meeting.mediaProperties.shareTrack, track);
+            assert.equal(meeting.mediaProperties.mediaDirection.sendShare, true);
+          };
+
+          it('requests screen share floor and publishes the screen share video track', async () => {
+            await meeting.publishTracks({screenShare: {video: videoShareTrack}});
+
+            assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
+            checkScreenShareVideoPublished(videoShareTrack);
+          });
+
+          it('updates MuteState instance and publishes the track for main audio', async () => {
+            await meeting.publishTracks({microphone: audioTrack});
+
+            assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
+            checkAudioPublished(audioTrack);
+          });
+
+          it('updates MuteState instance and publishes the track for main video', async () => {
+            await meeting.publishTracks({camera: videoTrack});
+
+            assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
+            checkVideoPublished(videoTrack);
+          });
+
+          it('publishes audio, video and screen share together', async () => {
+            await meeting.publishTracks({
+              microphone: audioTrack,
+              camera: videoTrack,
+              screenShare: {
+                video: videoShareTrack,
+              },
+            });
+
+            assert.calledThrice(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
+            checkAudioPublished(audioTrack);
+            checkVideoPublished(videoTrack);
+            checkScreenShareVideoPublished(videoShareTrack);
+          });
+        });
+        it('creates instance and publishes with annotation info', async () => {
+          const annotationInfo = {
+            version: '1',
+            policy: ANNOTATION_POLICY.APPROVAL,
+          };
+          await meeting.publishTracks({annotationInfo});
+          assert.equal(meeting.annotationInfo, annotationInfo);
+        });
+
+        describe('unpublishTracks', () => {
+          beforeEach(async () => {
+            await meeting.publishTracks({
+              microphone: audioTrack,
+              camera: videoTrack,
+              screenShare: {video: videoShareTrack},
+            });
+          });
+
+          const checkAudioUnpublished = () => {
+            assert.calledWith(
+              meeting.mediaProperties.webrtcMediaConnection.unpublishTrack,
+              audioTrack
+            );
+
+            assert.equal(meeting.mediaProperties.audioTrack, null);
+            assert.equal(meeting.mediaProperties.mediaDirection.sendAudio, 'fake value');
+          };
+
+          const checkVideoUnpublished = () => {
+            assert.calledWith(
+              meeting.mediaProperties.webrtcMediaConnection.unpublishTrack,
+              videoTrack
+            );
+
+            assert.equal(meeting.mediaProperties.videoTrack, null);
+            assert.equal(meeting.mediaProperties.mediaDirection.sendVideo, 'fake value');
+          };
+
+          const checkScreenShareVideoUnpublished = () => {
+            assert.calledWith(
+              meeting.mediaProperties.webrtcMediaConnection.unpublishTrack,
+              videoShareTrack
+            );
+
+            assert.calledOnce(meeting.requestScreenShareFloor);
+
+            assert.equal(meeting.mediaProperties.shareTrack, null);
+            assert.equal(meeting.mediaProperties.mediaDirection.sendShare, false);
+          };
+
+          it('fails if there is no media connection', async () => {
+            meeting.mediaProperties.webrtcMediaConnection = undefined;
+            await assert.isRejected(
+              meeting.unpublishTracks([audioTrack, videoTrack, videoShareTrack])
+            );
+          });
+
+          it('un-publishes the tracks correctly (all 3 together)', async () => {
+            await meeting.unpublishTracks([audioTrack, videoTrack, videoShareTrack]);
+
+            assert.calledThrice(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack);
+            checkAudioUnpublished();
+            checkVideoUnpublished();
+            checkScreenShareVideoUnpublished();
+          });
+
+          it('un-publishes the audio track correctly', async () => {
+            await meeting.unpublishTracks([audioTrack]);
+
+            assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack);
+            checkAudioUnpublished();
+          });
+
+          it('un-publishes the video track correctly', async () => {
+            await meeting.unpublishTracks([videoTrack]);
 
-          assert.calledWithMatch(Metrics.postEvent, {event: eventType.MOVE_MEDIA});
-        });
+            assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack);
+            checkVideoUnpublished();
+          });
 
-        it('should call `MeetingUtil.joinMeetingOptions` with resourceId', async () => {
-          sinon.spy(MeetingUtil, 'joinMeetingOptions');
-          await meeting.moveFrom('resourceId');
+          it('un-publishes the screen share video track correctly', async () => {
+            await meeting.unpublishTracks([videoShareTrack]);
 
-          assert.calledWith(MeetingUtil.joinMeetingOptions, meeting);
-          assert.calledWith(MeetingUtil.leaveMeeting, meeting, {
-            resourceId: 'resourceId',
-            correlationId: meeting.correlationId,
-            moveMeeting: true,
+            assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack);
+            checkScreenShareVideoUnpublished();
           });
+        });
+      });
+    });
 
-          assert.calledOnce(Metrics.sendBehavioralMetric);
-          assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.MOVE_FROM_SUCCESS);
+    describe('#enableMusicMode', () => {
+      beforeEach(() => {
+        meeting.isMultistream = true;
+          meeting.mediaProperties.webrtcMediaConnection = {
+            setCodecParameters: sinon.stub().resolves({}),
+            deleteCodecParameters: sinon.stub().resolves({}),
+          };
+      });
+      [
+        {shouldEnableMusicMode: true},
+        {shouldEnableMusicMode: false},
+      ].forEach(({shouldEnableMusicMode}) => {
+        it(`fails if there is no media connection for shouldEnableMusicMode: ${shouldEnableMusicMode}`, async () => {
+          meeting.mediaProperties.webrtcMediaConnection = undefined;
+          await assert.isRejected(meeting.enableMusicMode(shouldEnableMusicMode));
         });
+      });
 
-        it('should throw an error if moveFrom call fails', async () => {
-          MeetingUtil.joinMeeting = sinon.stub().returns(Promise.reject());
-          try {
-            await meeting.moveFrom('resourceId');
-          } catch {
-            assert.calledOnce(Metrics.sendBehavioralMetric);
-            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.MOVE_FROM_FAILURE, {
-              correlation_id: meeting.correlationId,
-              locus_id: meeting.locusUrl.split('/').pop(),
-              reason: sinon.match.any,
-              stack: sinon.match.any,
-            });
-          }
+      it('should set the codec parameters when shouldEnableMusicMode is true', async () => {
+        await meeting.enableMusicMode(true);
+        assert.calledOnceWithExactly(meeting.mediaProperties.webrtcMediaConnection.setCodecParameters, MediaType.AudioMain, {
+          maxaveragebitrate: '64000',
+          maxplaybackrate: '48000',
         });
+        assert.notCalled(meeting.mediaProperties.webrtcMediaConnection.deleteCodecParameters);
+      });
+
+      it('should set the codec parameters when shouldEnableMusicMode is false', async () => {
+        await meeting.enableMusicMode(false);
+        assert.calledOnceWithExactly(meeting.mediaProperties.webrtcMediaConnection.deleteCodecParameters, MediaType.AudioMain, [
+          'maxaveragebitrate',
+          'maxplaybackrate',
+        ]);
+        assert.notCalled(meeting.mediaProperties.webrtcMediaConnection.setCodecParameters);
       });
     });
 
@@ -3446,75 +3916,6 @@ describe('plugin-meetings', () => {
           );
         });
       });
-      describe('#closeLocalShare', () => {
-        it('should stop the stream, and trigger a media:stopped event when the local share stream stops', async () => {
-          await meeting.closeLocalShare();
-          assert.calledTwice(TriggerProxy.trigger);
-
-          assert.equal(TriggerProxy.trigger.getCall(1).args[2], 'media:stopped');
-          assert.deepEqual(TriggerProxy.trigger.getCall(1).args[3], {type: 'localShare'});
-        });
-      });
-      describe('#closeLocalStream', () => {
-        it('should stop the stream, and trigger a media:stopped event when the local stream stops', async () => {
-          await meeting.closeLocalStream();
-          assert.calledTwice(TriggerProxy.trigger);
-          assert.calledWith(
-            TriggerProxy.trigger,
-            sinon.match.instanceOf(Meeting),
-            {file: 'meeting/index', function: 'closeLocalStream'},
-            'media:stopped',
-            {type: 'local'}
-          );
-        });
-      });
-      describe('#setLocalTracks', () => {
-        it('stores the current video device as the preferred video device', () => {
-          const videoDevice = 'video1';
-          const fakeTrack = {getSettings: () => ({deviceId: videoDevice})};
-          const fakeStream = 'stream1';
-
-          sandbox.stub(MeetingUtil, 'getTrack').returns({audioTrack: null, videoTrack: fakeTrack});
-          sandbox.stub(meeting.mediaProperties, 'setMediaSettings');
-          sandbox.stub(meeting.mediaProperties, 'setVideoDeviceId');
-
-          meeting.setLocalTracks(fakeStream);
-
-          assert.calledWith(meeting.mediaProperties.setVideoDeviceId, videoDevice);
-        });
-      });
-      describe('#setLocalShareTrack', () => {
-        it('should trigger a media:ready event with local share stream', () => {
-          const track = {
-            getSettings: sinon.stub().returns({
-              aspectRatio: '1.7',
-              frameRate: 30,
-              height: 1980,
-              width: 1080,
-              displaySurface: true,
-              cursor: true,
-            }),
-          };
-          const getVideoTracks = sinon.stub().returns([track]);
-
-          meeting.mediaProperties.setLocalShareTrack = sinon.stub().returns(true);
-          meeting.mediaProperties.shareTrack = {getVideoTracks, getSettings: track.getSettings};
-          meeting.stopShare = sinon.stub().resolves(true);
-          meeting.mediaProperties.mediaDirection = {};
-          meeting.setLocalShareTrack(test1);
-          assert.calledTwice(TriggerProxy.trigger);
-          assert.calledWith(
-            TriggerProxy.trigger,
-            sinon.match.instanceOf(Meeting),
-            {file: 'meeting/index', function: 'setLocalShareTrack'},
-            'media:ready'
-          );
-          assert.calledOnce(meeting.mediaProperties.setLocalShareTrack);
-          assert.equal(meeting.mediaProperties.localStream, undefined);
-          meeting.mediaProperties.shareTrack.onended();
-          assert.calledOnce(meeting.stopShare);
-        });
-      });
       describe('#setupMediaConnectionListeners', () => {
         let eventListeners;
 
@@ -3527,48 +3928,49 @@ describe('plugin-meetings', () => {
               eventListeners[event] = listener;
             }),
           };
+          MediaUtil.createMediaStream.returns({id: 'stream'});
         });
 
         it('should register for all the correct RoapMediaConnection events', () => {
           meeting.setupMediaConnectionListeners();
-          assert.isFunction(eventListeners[MC.Event.ROAP_STARTED]);
-          assert.isFunction(eventListeners[MC.Event.ROAP_DONE]);
-          assert.isFunction(eventListeners[MC.Event.ROAP_FAILURE]);
-          assert.isFunction(eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]);
-          assert.isFunction(eventListeners[MC.Event.REMOTE_TRACK_ADDED]);
-          assert.isFunction(eventListeners[MC.Event.CONNECTION_STATE_CHANGED]);
+          assert.isFunction(eventListeners[Event.ROAP_STARTED]);
+          assert.isFunction(eventListeners[Event.ROAP_DONE]);
+          assert.isFunction(eventListeners[Event.ROAP_FAILURE]);
+          assert.isFunction(eventListeners[Event.ROAP_MESSAGE_TO_SEND]);
+          assert.isFunction(eventListeners[Event.REMOTE_TRACK_ADDED]);
+          assert.isFunction(eventListeners[Event.CONNECTION_STATE_CHANGED]);
         });
 
         it('should trigger a media:ready event when REMOTE_TRACK_ADDED is fired', () => {
           meeting.setupMediaConnectionListeners();
-          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({
+          eventListeners[Event.REMOTE_TRACK_ADDED]({
             track: 'track',
-            type: MC.RemoteTrackType.AUDIO,
+            type: RemoteTrackType.AUDIO,
           });
           assert.equal(TriggerProxy.trigger.getCall(1).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(1).args[3], {
             type: 'remoteAudio',
-            stream: true,
+            stream: {id: 'stream'},
           });
 
-          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({
+          eventListeners[Event.REMOTE_TRACK_ADDED]({
             track: 'track',
-            type: MC.RemoteTrackType.VIDEO,
+            type: RemoteTrackType.VIDEO,
           });
           assert.equal(TriggerProxy.trigger.getCall(2).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(2).args[3], {
             type: 'remoteVideo',
-            stream: true,
+            stream: {id: 'stream'},
           });
 
-          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({
+          eventListeners[Event.REMOTE_TRACK_ADDED]({
             track: 'track',
-            type: MC.RemoteTrackType.SCREENSHARE_VIDEO,
+            type: RemoteTrackType.SCREENSHARE_VIDEO,
           });
           assert.equal(TriggerProxy.trigger.getCall(3).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(3).args[3], {
             type: 'remoteShare',
-            stream: true,
+            stream: {id: 'stream'},
           });
         });
 
@@ -3613,51 +4015,51 @@ describe('plugin-meetings', () => {
           };
 
           it('should send metrics for SdpOfferCreationError error', () => {
-            const fakeError = new MC.Errors.SdpOfferCreationError(fakeErrorMessage, {
+            const fakeError = new Errors.SdpOfferCreationError(fakeErrorMessage, {
               name: fakeErrorName,
               cause: {name: fakeRootCauseName},
             });
 
-            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+            eventListeners[Event.ROAP_FAILURE](fakeError);
 
             checkMetricSent(eventType.LOCAL_SDP_GENERATED);
             checkBehavioralMetricSent(
               BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE,
-              MC.Errors.ErrorCode.SdpOfferCreationError,
+              Errors.ErrorCode.SdpOfferCreationError,
               fakeErrorMessage,
               fakeRootCauseName
             );
           });
 
           it('should send metrics for SdpOfferHandlingError error', () => {
-            const fakeError = new MC.Errors.SdpOfferHandlingError(fakeErrorMessage, {
+            const fakeError = new Errors.SdpOfferHandlingError(fakeErrorMessage, {
               name: fakeErrorName,
               cause: {name: fakeRootCauseName},
             });
 
-            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+            eventListeners[Event.ROAP_FAILURE](fakeError);
 
             checkMetricSent(eventType.REMOTE_SDP_RECEIVED);
             checkBehavioralMetricSent(
               BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE,
-              MC.Errors.ErrorCode.SdpOfferHandlingError,
+              Errors.ErrorCode.SdpOfferHandlingError,
               fakeErrorMessage,
               fakeRootCauseName
             );
           });
 
           it('should send metrics for SdpAnswerHandlingError error', () => {
-            const fakeError = new MC.Errors.SdpAnswerHandlingError(fakeErrorMessage, {
+            const fakeError = new Errors.SdpAnswerHandlingError(fakeErrorMessage, {
               name: fakeErrorName,
               cause: {name: fakeRootCauseName},
             });
 
-            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+            eventListeners[Event.ROAP_FAILURE](fakeError);
 
             checkMetricSent(eventType.REMOTE_SDP_RECEIVED);
             checkBehavioralMetricSent(
               BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE,
-              MC.Errors.ErrorCode.SdpAnswerHandlingError,
+              Errors.ErrorCode.SdpAnswerHandlingError,
               fakeErrorMessage,
               fakeRootCauseName
             );
@@ -3665,15 +4067,15 @@ describe('plugin-meetings', () => {
 
           it('should send metrics for SdpError error', () => {
             // SdpError is usually without a cause
-            const fakeError = new MC.Errors.SdpError(fakeErrorMessage, {name: fakeErrorName});
+            const fakeError = new Errors.SdpError(fakeErrorMessage, {name: fakeErrorName});
 
-            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+            eventListeners[Event.ROAP_FAILURE](fakeError);
 
             checkMetricSent(eventType.LOCAL_SDP_GENERATED);
             // expectedMetadataType is the error name in this case
             checkBehavioralMetricSent(
               BEHAVIORAL_METRICS.INVALID_ICE_CANDIDATE,
-              MC.Errors.ErrorCode.SdpError,
+              Errors.ErrorCode.SdpError,
               fakeErrorMessage,
               fakeErrorName
             );
@@ -3681,24 +4083,24 @@ describe('plugin-meetings', () => {
 
           it('should send metrics for IceGatheringError error', () => {
             // IceGatheringError is usually without a cause
-            const fakeError = new MC.Errors.IceGatheringError(fakeErrorMessage, {
+            const fakeError = new Errors.IceGatheringError(fakeErrorMessage, {
               name: fakeErrorName,
             });
 
-            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+            eventListeners[Event.ROAP_FAILURE](fakeError);
 
             checkMetricSent(eventType.LOCAL_SDP_GENERATED);
             // expectedMetadataType is the error name in this case
             checkBehavioralMetricSent(
               BEHAVIORAL_METRICS.INVALID_ICE_CANDIDATE,
-              MC.Errors.ErrorCode.IceGatheringError,
+              Errors.ErrorCode.IceGatheringError,
               fakeErrorMessage,
               fakeErrorName
             );
           });
         });
 
-        describe('handles MC.Event.ROAP_MESSAGE_TO_SEND correctly', () => {
+        describe('handles Event.ROAP_MESSAGE_TO_SEND correctly', () => {
           let sendRoapOKStub;
           let sendRoapMediaRequestStub;
           let sendRoapAnswerStub;
@@ -3716,7 +4118,7 @@ describe('plugin-meetings', () => {
           });
 
           it('handles OK message correctly', () => {
-            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {messageType: 'OK', seq: 1},
             });
 
@@ -3735,7 +4137,7 @@ describe('plugin-meetings', () => {
           });
 
           it('handles OFFER message correctly', () => {
-            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {
                 messageType: 'OFFER',
                 seq: 1,
@@ -3761,7 +4163,7 @@ describe('plugin-meetings', () => {
           });
 
           it('handles ANSWER message correctly', () => {
-            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {
                 messageType: 'ANSWER',
                 seq: 10,
@@ -3788,7 +4190,7 @@ describe('plugin-meetings', () => {
           it('sends metrics if fails to send roap ANSWER message', async () => {
             sendRoapAnswerStub.rejects(new Error('sending answer failed'));
 
-            await eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+            await eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {
                 messageType: 'ANSWER',
                 seq: 10,
@@ -3810,88 +4212,401 @@ describe('plugin-meetings', () => {
             );
           });
 
-          [MC.ErrorType.CONFLICT, MC.ErrorType.DOUBLECONFLICT].forEach((errorType) =>
-            it(`handles ERROR message indicating glare condition correctly (errorType=${errorType})`, () => {
-              eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
-                roapMessage: {
-                  messageType: 'ERROR',
-                  seq: 10,
-                  errorType,
-                  tieBreaker: 12345,
-                },
-              });
+          [ErrorType.CONFLICT, ErrorType.DOUBLECONFLICT].forEach((errorType) =>
+            it(`handles ERROR message indicating glare condition correctly (errorType=${errorType})`, () => {
+              eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
+                roapMessage: {
+                  messageType: 'ERROR',
+                  seq: 10,
+                  errorType,
+                  tieBreaker: 12345,
+                },
+              });
+
+              assert.calledOnce(Metrics.sendBehavioralMetric);
+              assert.calledWithMatch(
+                Metrics.sendBehavioralMetric,
+                BEHAVIORAL_METRICS.ROAP_GLARE_CONDITION,
+                {
+                  correlation_id: meeting.correlationId,
+                  locus_id: meeting.locusUrl.split('/').pop(),
+                  sequence: 10,
+                }
+              );
+
+              assert.calledOnce(sendRoapErrorStub);
+              assert.calledWith(sendRoapErrorStub, {
+                seq: 10,
+                errorType,
+                mediaId: meeting.mediaId,
+                correlationId: meeting.correlationId,
+              });
+            })
+          );
+
+          it('handles ERROR message indicating other errors correctly', () => {
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
+              roapMessage: {
+                messageType: 'ERROR',
+                seq: 10,
+                errorType: ErrorType.FAILED,
+                tieBreaker: 12345,
+              },
+            });
+
+            assert.notCalled(Metrics.sendBehavioralMetric);
+
+            assert.calledOnce(sendRoapErrorStub);
+            assert.calledWith(sendRoapErrorStub, {
+              seq: 10,
+              errorType: ErrorType.FAILED,
+              mediaId: meeting.mediaId,
+              correlationId: meeting.correlationId,
+            });
+          });
+        });
+      });
+      describe('#setUpLocusInfoSelfListener', () => {
+        it('listens to the self unadmitted guest event', (done) => {
+          meeting.startKeepAlive = sinon.stub();
+          meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_UNADMITTED_GUEST', test1);
+          assert.calledOnceWithExactly(meeting.startKeepAlive);
+          assert.calledTwice(TriggerProxy.trigger);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            sinon.match.instanceOf(Meeting),
+            {file: 'meeting/index', function: 'setUpLocusInfoSelfListener'},
+            'meeting:self:lobbyWaiting',
+            {payload: test1}
+          );
+          done();
+        });
+        it('listens to the self admitted guest event', (done) => {
+          meeting.stopKeepAlive = sinon.stub();
+          meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_ADMITTED_GUEST', test1);
+          assert.calledOnceWithExactly(meeting.stopKeepAlive);
+          assert.calledTwice(TriggerProxy.trigger);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            sinon.match.instanceOf(Meeting),
+            {file: 'meeting/index', function: 'setUpLocusInfoSelfListener'},
+            'meeting:self:guestAdmitted',
+            {payload: test1}
+          );
+          done();
+        });
+
+        it('listens to the breakouts changed event', () => {
+          meeting.breakouts.updateBreakoutSessions = sinon.stub();
+
+          const payload = 'payload';
+
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'SELF_MEETING_BREAKOUTS_CHANGED',
+            payload
+          );
+
+          assert.calledOnceWithExactly(meeting.breakouts.updateBreakoutSessions, payload);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpLocusInfoSelfListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_UPDATE
+          );
+        });
+
+        it('listens to the self roles changed event', () => {
+          const payload = {oldRoles: [], newRoles: ['COHOST']};
+          meeting.breakouts.updateCanManageBreakouts = sinon.stub();
+
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'SELF_ROLES_CHANGED',
+            payload
+          );
+
+          assert.calledOnceWithExactly(meeting.breakouts.updateCanManageBreakouts, true);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpLocusInfoSelfListener'},
+            EVENT_TRIGGERS.MEETING_SELF_ROLES_CHANGED,
+            {payload}
+          );
+        });
+      });
+
+      describe('#setUpBreakoutsListener', () => {
+        it('listens to the closing event from breakouts and triggers the closing event', () => {
+          TriggerProxy.trigger.reset();
+          meeting.breakouts.trigger('BREAKOUTS_CLOSING');
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpBreakoutsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_CLOSING
+          );
+        });
+
+        it('listens to the message event from breakouts and triggers the message event', () => {
+          TriggerProxy.trigger.reset();
+
+          const messageEvent = 'message';
+
+          meeting.breakouts.trigger('MESSAGE', messageEvent);
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpBreakoutsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_MESSAGE,
+            messageEvent
+          );
+        });
+
+        it('listens to the members update event from breakouts and triggers the breakouts update event', () => {
+          TriggerProxy.trigger.reset();
+          meeting.breakouts.trigger('MEMBERS_UPDATE');
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpBreakoutsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_UPDATE
+          );
+        });
+
+        it('listens to the ask return to main event from breakouts and triggers the ask return to main event from meeting', () => {
+          TriggerProxy.trigger.reset();
+          meeting.breakouts.trigger('ASK_RETURN_TO_MAIN');
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpBreakoutsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_ASK_RETURN_TO_MAIN
+          );
+        });
+
+        it('listens to the leave event from breakouts and triggers the breakout leave event', () => {
+          TriggerProxy.trigger.reset();
+          meeting.breakouts.trigger('LEAVE_BREAKOUT');
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpBreakoutsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_LEAVE
+          );
+        });
+
+        it('listens to the breakout ask for help event and triggers the ask for help event', () => {
+          TriggerProxy.trigger.reset();
+          const helpEvent = {sessionId:'sessionId', participant: 'participant'}
+          meeting.breakouts.trigger('ASK_FOR_HELP', helpEvent);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpBreakoutsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_ASK_FOR_HELP,
+            helpEvent
+          );
+        });
+
+        it('listens to the preAssignments update event from breakouts and triggers the update event', () => {
+          TriggerProxy.trigger.reset();
+          meeting.breakouts.trigger('PRE_ASSIGNMENTS_UPDATE');
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpBreakoutsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_PRE_ASSIGNMENTS_UPDATE
+          );
+        });
+      });
+
+      describe('#setupLocusControlsListener', () => {
+        it('listens to the locus breakouts update event', () => {
+          const locus = {
+            breakout: 'breakout',
+          };
+
+          meeting.breakouts.updateBreakout = sinon.stub();
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'CONTROLS_MEETING_BREAKOUT_UPDATED',
+            locus
+          );
+
+          assert.calledOnceWithExactly(meeting.breakouts.updateBreakout, locus.breakout);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_UPDATE
+          );
+        });
+
+        it('listens to CONTROLS_MUTE_ON_ENTRY_CHANGED', async () => {
+          const state = {example: 'value'}
+
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_MUTE_ON_ENTRY_CHANGED,
+            {state}
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_MUTE_ON_ENTRY_UPDATED,
+            {state},
+          );
+        });
+
+        it('listens to MEETING_CONTROLS_SHARE_CONTROL_UPDATED', async () => {
+          const state = {example: 'value'}
+
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_SHARE_CONTROL_CHANGED,
+            {state}
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_SHARE_CONTROL_UPDATED,
+            {state},
+          );
+        });
+
+        it('listens to MEETING_CONTROLS_DISALLOW_UNMUTE_UPDATED', async () => {
+          const state = {example: 'value'}
 
-              assert.calledOnce(Metrics.sendBehavioralMetric);
-              assert.calledWithMatch(
-                Metrics.sendBehavioralMetric,
-                BEHAVIORAL_METRICS.ROAP_GLARE_CONDITION,
-                {
-                  correlation_id: meeting.correlationId,
-                  locus_id: meeting.locusUrl.split('/').pop(),
-                  sequence: 10,
-                }
-              );
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_DISALLOW_UNMUTE_CHANGED,
+            {state}
+          );
 
-              assert.calledOnce(sendRoapErrorStub);
-              assert.calledWith(sendRoapErrorStub, {
-                seq: 10,
-                errorType,
-                mediaId: meeting.mediaId,
-                correlationId: meeting.correlationId,
-              });
-            })
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_DISALLOW_UNMUTE_UPDATED,
+            {state},
           );
+        });
 
-          it('handles ERROR message indicating other errors correctly', () => {
-            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
-              roapMessage: {
-                messageType: 'ERROR',
-                seq: 10,
-                errorType: MC.ErrorType.FAILED,
-                tieBreaker: 12345,
-              },
-            });
+        it('listens to MEETING_CONTROLS_REACTIONS_UPDATED', async () => {
+          const state = {example: 'value'}
 
-            assert.notCalled(Metrics.sendBehavioralMetric);
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_REACTIONS_CHANGED,
+            {state}
+          );
 
-            assert.calledOnce(sendRoapErrorStub);
-            assert.calledWith(sendRoapErrorStub, {
-              seq: 10,
-              errorType: MC.ErrorType.FAILED,
-              mediaId: meeting.mediaId,
-              correlationId: meeting.correlationId,
-            });
-          });
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_REACTIONS_UPDATED,
+            {state},
+          );
         });
-      });
-      describe('#setUpLocusInfoSelfListener', () => {
-        it('listens to the self unadmitted guest event', (done) => {
-          meeting.startKeepAlive = sinon.stub();
-          meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_UNADMITTED_GUEST', test1);
-          assert.calledOnceWithExactly(meeting.startKeepAlive);
-          assert.calledTwice(TriggerProxy.trigger);
+
+        it('listens to MEETING_CONTROLS_VIEW_THE_PARTICIPANTS_LIST_UPDATED', async () => {
+          const state = {example: 'value'}
+
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_VIEW_THE_PARTICIPANTS_LIST_CHANGED,
+            {state}
+          );
+
           assert.calledWith(
             TriggerProxy.trigger,
-            sinon.match.instanceOf(Meeting),
-            {file: 'meeting/index', function: 'setUpLocusInfoSelfListener'},
-            'meeting:self:lobbyWaiting',
-            {payload: test1}
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_VIEW_THE_PARTICIPANTS_LIST_UPDATED,
+            {state},
           );
-          done();
         });
-        it('listens to the self admitted guest event', (done) => {
-          meeting.stopKeepAlive = sinon.stub();
-          meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_ADMITTED_GUEST', test1);
-          assert.calledOnceWithExactly(meeting.stopKeepAlive);
-          assert.calledTwice(TriggerProxy.trigger);
+
+        it('listens to MEETING_CONTROLS_RAISE_HAND_UPDATED', async () => {
+          const state = {example: 'value'}
+
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_RAISE_HAND_CHANGED,
+            {state}
+          );
+
           assert.calledWith(
             TriggerProxy.trigger,
-            sinon.match.instanceOf(Meeting),
-            {file: 'meeting/index', function: 'setUpLocusInfoSelfListener'},
-            'meeting:self:guestAdmitted',
-            {payload: test1}
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_RAISE_HAND_UPDATED,
+            {state},
           );
-          done();
+        });
+
+        it('listens to MEETING_CONTROLS_VIDEO_UPDATED', async () => {
+          const state = {example: 'value'}
+
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_VIDEO_CHANGED,
+            {state}
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_VIDEO_UPDATED,
+            {state},
+          );
+        });
+
+        it('listens to the timing that user joined into breakout', async () => {
+          const mainLocusUrl = 'mainLocusUrl123';
+
+          meeting.meetingRequest.getLocusStatusByUrl = sinon.stub().returns(Promise.resolve());
+
+          await meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'CONTROLS_JOIN_BREAKOUT_FROM_MAIN',
+            {mainLocusUrl}
+          );
+
+          assert.calledOnceWithExactly(meeting.meetingRequest.getLocusStatusByUrl, mainLocusUrl);
+          const error = {statusCode: 403};
+          meeting.meetingRequest.getLocusStatusByUrl.rejects(error);
+          meeting.locusInfo.clearMainSessionLocusCache = sinon.stub();
+          await meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'CONTROLS_JOIN_BREAKOUT_FROM_MAIN',
+            {mainLocusUrl}
+          );
+
+          assert.calledOnce(meeting.locusInfo.clearMainSessionLocusCache);
+
+          const otherError = new Error('something wrong');
+          meeting.meetingRequest.getLocusStatusByUrl.rejects(otherError);
+          meeting.locusInfo.clearMainSessionLocusCache = sinon.stub();
+          await meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'CONTROLS_JOIN_BREAKOUT_FROM_MAIN',
+            {mainLocusUrl}
+          );
+
+          assert.notCalled(meeting.locusInfo.clearMainSessionLocusCache);
         });
       });
 
@@ -3900,6 +4615,11 @@ describe('plugin-meetings', () => {
           const newLocusUrl = 'newLocusUrl/12345';
 
           meeting.members = {locusUrlUpdate: sinon.stub().returns(Promise.resolve(test1))};
+          meeting.recordingController = {setLocusUrl: sinon.stub().returns(undefined)};
+          meeting.controlsOptionsManager = {setLocusUrl: sinon.stub().returns(undefined)};
+
+          meeting.breakouts.locusUrlUpdate = sinon.stub();
+          meeting.annotation.locusUrlUpdate = sinon.stub();
 
           meeting.locusInfo.emit(
             {function: 'test', file: 'test'},
@@ -3907,11 +4627,57 @@ describe('plugin-meetings', () => {
             newLocusUrl
           );
           assert.calledWith(meeting.members.locusUrlUpdate, newLocusUrl);
+          assert.calledOnceWithExactly(meeting.breakouts.locusUrlUpdate, newLocusUrl);
+          assert.calledOnceWithExactly(meeting.annotation.locusUrlUpdate, newLocusUrl);
+          assert.calledWith(meeting.members.locusUrlUpdate, newLocusUrl);
+          assert.calledWith(meeting.recordingController.setLocusUrl, newLocusUrl);
+          assert.calledWith(meeting.controlsOptionsManager.setLocusUrl, newLocusUrl);
           assert.equal(meeting.locusUrl, newLocusUrl);
           assert(meeting.locusId, '12345');
           done();
         });
       });
+
+      describe('#setUpLocusServicesListener', () => {
+        it('listens to the locus services update event', (done) => {
+          const newLocusServices = {
+            services: {
+              record: {
+                url: 'url',
+              },
+              approval: {
+                url: 'url',
+              },
+            },
+          };
+
+          meeting.recordingController = {
+            setServiceUrl: sinon.stub().returns(undefined),
+            setSessionId: sinon.stub().returns(undefined),
+          };
+          meeting.annotation = {
+            approvalUrlUpdate: sinon.stub().returns(undefined),
+          };
+
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'LINKS_SERVICES',
+            newLocusServices
+          );
+
+          assert.calledWith(
+            meeting.recordingController.setServiceUrl,
+            newLocusServices.services.record.url,
+          );
+          assert.calledWith(
+            meeting.annotation.approvalUrlUpdate,
+            newLocusServices.services.approval.url,
+          );
+          assert.calledOnce(meeting.recordingController.setSessionId);
+          done();
+        });
+      });
+
       describe('#setUpLocusInfoMediaInactiveListener', () => {
         it('listens to disconnect due to un activity ', (done) => {
           TriggerProxy.trigger.reset();
@@ -4057,20 +4823,6 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.mediaProperties.unsetRemoteTracks);
         });
       });
-      describe('#unsetLocalVideoTrack', () => {
-        it('should unset the local stream and return null', () => {
-          meeting.mediaProperties.unsetLocalVideoTrack = sinon.stub().returns(true);
-          meeting.unsetLocalVideoTrack();
-          assert.calledOnce(meeting.mediaProperties.unsetLocalVideoTrack);
-        });
-      });
-      describe('#unsetLocalShareTrack', () => {
-        it('should unset the local share stream and return null', () => {
-          meeting.mediaProperties.unsetLocalShareTrack = sinon.stub().returns(true);
-          meeting.unsetLocalShareTrack();
-          assert.calledOnce(meeting.mediaProperties.unsetLocalShareTrack);
-        });
-      });
       // TODO: remove
       describe('#setMercuryListener', () => {
         it('should listen to mercury events', () => {
@@ -4237,28 +4989,7 @@ describe('plugin-meetings', () => {
           checkParseMeetingInfo(expectedInfoToParse);
         });
       });
-      describe('#parseLocus', () => {
-        describe('when CALL and participants', () => {
-          beforeEach(() => {
-            meeting.setLocus = sinon.stub().returns(true);
-            MeetingUtil.getLocusPartner = sinon.stub().returns({person: {sipUrl: uuid3}});
-          });
-          it('should parse the locus object and set meeting properties and return null', () => {
-            meeting.type = 'CALL';
-            meeting.parseLocus({url: url1, participants: [{id: uuid1}], self: {id: uuid2}});
-            assert.calledOnce(meeting.setLocus);
-            assert.calledWith(meeting.setLocus, {
-              url: url1,
-              participants: [{id: uuid1}],
-              self: {id: uuid2},
-            });
-            assert.calledOnce(MeetingUtil.getLocusPartner);
-            assert.calledWith(MeetingUtil.getLocusPartner, [{id: uuid1}], {id: uuid2});
-            assert.deepEqual(meeting.partner, {person: {sipUrl: uuid3}});
-            assert.equal(meeting.sipUri, uuid3);
-          });
-        });
-      });
+
       describe('#setCorrelationId', () => {
         it('should set the correlationId and return undefined', () => {
           assert.ok(meeting.correlationId);
@@ -4319,25 +5050,37 @@ describe('plugin-meetings', () => {
         let inMeetingActionsSetSpy;
         let canUserLockSpy;
         let canUserUnlockSpy;
-        let canUserRecordSpy;
+        let canUserStartSpy;
         let canUserStopSpy;
         let canUserPauseSpy;
         let canUserResumeSpy;
+        let canSetMuteOnEntrySpy;
+        let canUnsetMuteOnEntrySpy;
+        let canSetDisallowUnmuteSpy;
+        let canUnsetDisallowUnmuteSpy;
         let canUserRaiseHandSpy;
         let bothLeaveAndEndMeetingAvailableSpy;
         let canUserLowerAllHandsSpy;
         let canUserLowerSomeoneElsesHandSpy;
         let waitingForOthersToJoinSpy;
         let handleDataChannelUrlChangeSpy;
+        let canSendReactionsSpy;
+        let canUserRenameSelfAndObservedSpy;
+        let canUserRenameOthersSpy;
+        let hasHintsSpy;
 
         beforeEach(() => {
           locusInfoOnSpy = sinon.spy(meeting.locusInfo, 'on');
           canUserLockSpy = sinon.spy(MeetingUtil, 'canUserLock');
           canUserUnlockSpy = sinon.spy(MeetingUtil, 'canUserUnlock');
-          canUserRecordSpy = sinon.spy(MeetingUtil, 'canUserRecord');
-          canUserStopSpy = sinon.spy(MeetingUtil, 'canUserStop');
-          canUserPauseSpy = sinon.spy(MeetingUtil, 'canUserPause');
-          canUserResumeSpy = sinon.spy(MeetingUtil, 'canUserResume');
+          canUserStartSpy = sinon.spy(RecordingUtil, 'canUserStart');
+          canUserStopSpy = sinon.spy(RecordingUtil, 'canUserStop');
+          canUserPauseSpy = sinon.spy(RecordingUtil, 'canUserPause');
+          canUserResumeSpy = sinon.spy(RecordingUtil, 'canUserResume');
+          canSetMuteOnEntrySpy = sinon.spy(ControlsOptionsUtil, 'canSetMuteOnEntry');
+          canUnsetMuteOnEntrySpy = sinon.spy(ControlsOptionsUtil, 'canUnsetMuteOnEntry');
+          canSetDisallowUnmuteSpy = sinon.spy(ControlsOptionsUtil, 'canSetDisallowUnmute');
+          canUnsetDisallowUnmuteSpy = sinon.spy(ControlsOptionsUtil, 'canUnsetDisallowUnmute');
           inMeetingActionsSetSpy = sinon.spy(meeting.inMeetingActions, 'set');
           canUserRaiseHandSpy = sinon.spy(MeetingUtil, 'canUserRaiseHand');
           canUserLowerAllHandsSpy = sinon.spy(MeetingUtil, 'canUserLowerAllHands');
@@ -4348,6 +5091,9 @@ describe('plugin-meetings', () => {
           canUserLowerSomeoneElsesHandSpy = sinon.spy(MeetingUtil, 'canUserLowerSomeoneElsesHand');
           waitingForOthersToJoinSpy = sinon.spy(MeetingUtil, 'waitingForOthersToJoin');
           handleDataChannelUrlChangeSpy = sinon.spy(meeting, 'handleDataChannelUrlChange');
+          canSendReactionsSpy = sinon.spy(MeetingUtil, 'canSendReactions');
+          canUserRenameSelfAndObservedSpy = sinon.spy(MeetingUtil, 'canUserRenameSelfAndObserved');
+          canUserRenameOthersSpy = sinon.spy(MeetingUtil, 'canUserRenameOthers');
         });
 
         afterEach(() => {
@@ -4357,6 +5103,10 @@ describe('plugin-meetings', () => {
         });
 
         it('registers the correct MEETING_INFO_UPDATED event', () => {
+          // Due to import tree issues, hasHints must be stubed within the scope of the `it`.
+          const restorableHasHints = ControlsOptionsUtil.hasHints;
+          ControlsOptionsUtil.hasHints = sinon.stub().returns(true);
+
           meeting.setUpLocusInfoMeetingInfoListener();
 
           assert.calledThrice(locusInfoOnSpy);
@@ -4377,16 +5127,96 @@ describe('plugin-meetings', () => {
 
           assert.calledWith(canUserLockSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserUnlockSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUserRecordSpy, payload.info.userDisplayHints);
+          assert.calledWith(canUserStartSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserStopSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserPauseSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserResumeSpy, payload.info.userDisplayHints);
+          assert.calledWith(canSetMuteOnEntrySpy, payload.info.userDisplayHints);
+          assert.calledWith(canUnsetMuteOnEntrySpy, payload.info.userDisplayHints);
+          assert.calledWith(canSetDisallowUnmuteSpy, payload.info.userDisplayHints);
+          assert.calledWith(canUnsetDisallowUnmuteSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserRaiseHandSpy, payload.info.userDisplayHints);
           assert.calledWith(bothLeaveAndEndMeetingAvailableSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserLowerAllHandsSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserLowerSomeoneElsesHandSpy, payload.info.userDisplayHints);
           assert.calledWith(waitingForOthersToJoinSpy, payload.info.userDisplayHints);
           assert.calledWith(handleDataChannelUrlChangeSpy, payload.info.datachannelUrl);
+          assert.calledWith(canSendReactionsSpy, null, payload.info.userDisplayHints);
+          assert.calledWith(canUserRenameSelfAndObservedSpy, payload.info.userDisplayHints);
+          assert.calledWith(canUserRenameOthersSpy, payload.info.userDisplayHints);
+
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.MUTE_ALL],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.UNMUTE_ALL],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.ENABLE_HARD_MUTE],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.DISABLE_HARD_MUTE],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.ENABLE_MUTE_ON_ENTRY],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.DISABLE_MUTE_ON_ENTRY],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.ENABLE_REACTIONS],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.DISABLE_REACTIONS],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.ENABLE_SHOW_DISPLAY_NAME],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.DISABLE_SHOW_DISPLAY_NAME],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.SHARE_CONTROL],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.DISABLE_VIEW_THE_PARTICIPANT_LIST],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.SHARE_FILE],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.SHARE_APPLICATION],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.SHARE_CAMERA],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.SHARE_DESKTOP],
+            displayHints: payload.info.userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.SHARE_CONTENT],
+            displayHints: payload.info.userDisplayHints,
+          });
 
           assert.calledWith(
             TriggerProxy.trigger,
@@ -4404,6 +5234,8 @@ describe('plugin-meetings', () => {
           callback(payload);
 
           assert.notCalled(TriggerProxy.trigger);
+
+          ControlsOptionsUtil.hasHints = restorableHasHints;
         });
       });
 
@@ -4451,6 +5283,9 @@ describe('plugin-meetings', () => {
             .stub()
             .returns(Promise.resolve('something'));
           webex.internal.llm.disconnectLLM = sinon.stub().returns(Promise.resolve());
+          meeting.webex.internal.llm.on = sinon.stub();
+          meeting.webex.internal.llm.off = sinon.stub();
+          meeting.processRelayEvent = sinon.stub();
         });
 
         it('does not connect if the call is not joined yet', async () => {
@@ -4464,6 +5299,7 @@ describe('plugin-meetings', () => {
           assert.notCalled(webex.internal.llm.registerAndConnect);
           assert.notCalled(webex.internal.llm.disconnectLLM);
           assert.equal(result, undefined);
+          assert.notCalled(meeting.webex.internal.llm.on);
         });
 
         it('returns undefined if llm is already connected and the locus url is unchanged', async () => {
@@ -4478,17 +5314,29 @@ describe('plugin-meetings', () => {
           assert.notCalled(webex.internal.llm.registerAndConnect);
           assert.notCalled(webex.internal.llm.disconnectLLM);
           assert.equal(result, undefined);
+          assert.notCalled(meeting.webex.internal.llm.on);
         });
 
         it('connects if not already connected', async () => {
           meeting.joinedWith = {state: 'JOINED'};
           meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
 
+
           const result = await meeting.updateLLMConnection();
 
           assert.notCalled(webex.internal.llm.disconnectLLM);
           assert.calledWith(webex.internal.llm.registerAndConnect, 'a url', 'a datachannel url');
           assert.equal(result, 'something');
+          assert.calledOnceWithExactly(
+            meeting.webex.internal.llm.off,
+            'event:relay.event',
+            meeting.processRelayEvent
+          );
+          assert.calledOnceWithExactly(
+            meeting.webex.internal.llm.on,
+            'event:relay.event',
+            meeting.processRelayEvent
+          );
         });
 
         it('disconnects if first if the locus url has changed', async () => {
@@ -4507,6 +5355,19 @@ describe('plugin-meetings', () => {
             'a datachannel url'
           );
           assert.equal(result, 'something');
+          assert.calledWithExactly(
+            meeting.webex.internal.llm.off,
+            'event:relay.event',
+            meeting.processRelayEvent
+          );
+          assert.calledTwice(
+            meeting.webex.internal.llm.off
+          );
+          assert.calledOnceWithExactly(
+            meeting.webex.internal.llm.on,
+            'event:relay.event',
+            meeting.processRelayEvent
+          );
         });
 
         it('disconnects when the state is not JOINED', async () => {
@@ -4521,15 +5382,22 @@ describe('plugin-meetings', () => {
           assert.calledWith(webex.internal.llm.disconnectLLM);
           assert.notCalled(webex.internal.llm.registerAndConnect);
           assert.equal(result, undefined);
+          assert.calledOnceWithExactly(
+            meeting.webex.internal.llm.off,
+            'event:relay.event',
+            meeting.processRelayEvent
+          );
         });
+
       });
 
       describe('#setLocus', () => {
         beforeEach(() => {
           meeting.locusInfo.initialSetup = sinon.stub().returns(true);
         });
+
         it('should read the locus object, set on the meeting and return null', () => {
-          meeting.parseLocus({
+          meeting.setLocus({
             mediaConnections: [test1],
             locusUrl: url1,
             locusId: uuid1,
@@ -4554,6 +5422,7 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.hostId, uuid4);
         });
       });
+
       describe('preferred video device', () => {
         describe('#getVideoDeviceId', () => {
           it('returns the preferred video device', () => {
@@ -4620,14 +5489,53 @@ describe('plugin-meetings', () => {
         });
       });
       describe('share scenarios', () => {
+
+        describe('triggerAnnotationInfoEvent', () => {
+          it('check triggerAnnotationInfoEvent event', () => {
+
+            TriggerProxy.trigger.reset();
+            const annotationInfo = {version: '1', policy: 'Approval'};
+            meeting.triggerAnnotationInfoEvent({annotation:annotationInfo},{});
+
+            assert.calledWith(
+              TriggerProxy.trigger,
+              meeting,
+              {
+                file: 'meeting/index',
+                function: 'triggerAnnotationInfoEvent',
+              },
+              'meeting:updateAnnotationInfo',
+              annotationInfo
+            );
+
+            TriggerProxy.trigger.reset();
+            meeting.triggerAnnotationInfoEvent({annotation:annotationInfo},{annotation:annotationInfo});
+            assert.notCalled(TriggerProxy.trigger);
+
+            TriggerProxy.trigger.reset();
+            const annotationInfoUpdated = {version: '1', policy: 'AnnotationNotAllowed'};
+            meeting.triggerAnnotationInfoEvent({annotation:annotationInfoUpdated},{annotation:annotationInfo});
+            assert.calledWith(
+              TriggerProxy.trigger,
+              meeting,
+              {
+                file: 'meeting/index',
+                function: 'triggerAnnotationInfoEvent',
+              },
+              'meeting:updateAnnotationInfo',
+              annotationInfoUpdated
+            );
+
+            TriggerProxy.trigger.reset();
+            meeting.triggerAnnotationInfoEvent(null,{annotation:annotationInfoUpdated});
+            assert.notCalled(TriggerProxy.trigger);
+
+          });
+        });
+
         describe('setUpLocusMediaSharesListener', () => {
           beforeEach(() => {
             meeting.selfId = '9528d952-e4de-46cf-8157-fd4823b98377';
-            sinon.stub(meeting, 'updateShare').returns(Promise.resolve());
-          });
-
-          afterEach(() => {
-            meeting.updateShare.restore();
           });
 
           const USER_IDS = {
@@ -4643,7 +5551,7 @@ describe('plugin-meetings', () => {
               'https://board-a.wbx2.com/board/api/v1/channels/977a7330-54f4-11eb-b1ef-91f5eefc7bf3',
           };
 
-          const generateContent = (beneficiaryId = null, disposition = null) => ({
+          const generateContent = (beneficiaryId = null, disposition = null,annotation = undefined) => ({
             beneficiaryId,
             disposition,
           });
@@ -4660,7 +5568,10 @@ describe('plugin-meetings', () => {
             beneficiaryId,
             resourceUrl,
             isAccepting,
-            otherBeneficiaryId
+            otherBeneficiaryId,
+            annotation,
+            url,
+            shareInstanceId
           ) => {
             const newPayload = cloneDeep(payload);
 
@@ -4686,7 +5597,7 @@ describe('plugin-meetings', () => {
             if (isGranting) {
               if (isContent) {
                 activeSharingId.content = beneficiaryId;
-                newPayload.current.content = generateContent(beneficiaryId, FLOOR_ACTION.GRANTED);
+                newPayload.current.content = generateContent(beneficiaryId, FLOOR_ACTION.GRANTED,annotation);
 
                 if (isEqual(newPayload.current, newPayload.previous)) {
                   eventTrigger.member = null;
@@ -4740,7 +5651,7 @@ describe('plugin-meetings', () => {
                     eventTrigger.share.push({
                       eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_REMOTE,
                       functionName: 'remoteShare',
-                      eventPayload: {memberId: beneficiaryId},
+                      eventPayload: {memberId: beneficiaryId, url, shareInstanceId},
                     });
                   }
                 }
@@ -5312,7 +6223,6 @@ describe('plugin-meetings', () => {
               payloadTestHelper([data1, data2, data3]);
             });
           });
-
           describe('Desktop A --> Desktop B', () => {
             it('Scenario #1: you share desktop A and then share desktop B', () => {
               const data1 = generateData(blankPayload, true, true, USER_IDS.ME);
@@ -5529,7 +6439,7 @@ describe('plugin-meetings', () => {
         it('should send reaction with the right data and return a promise', async () => {
           meeting.locusInfo.controls = {reactions: {reactionChannelUrl: 'Fake URL'}};
 
-          const reactionPromise = meeting.sendReaction('thumbs_down', 'light');
+          const reactionPromise = meeting.sendReaction('thumb_down', 'light');
 
           assert.exists(reactionPromise.then);
           await reactionPromise;
@@ -5553,7 +6463,7 @@ describe('plugin-meetings', () => {
           meeting.locusInfo.controls = {reactions: {reactionChannelUrl: undefined}};
 
           await assert.isRejected(
-            meeting.sendReaction('thumbs_down', 'light'),
+            meeting.sendReaction('thumb_down', 'light'),
             Error,
             'Error sending reaction, service url not found.'
           );
@@ -5576,7 +6486,7 @@ describe('plugin-meetings', () => {
         it('should send a reaction with default skin tone if provided skinToneType is invalid ', async () => {
           meeting.locusInfo.controls = {reactions: {reactionChannelUrl: 'Fake URL'}};
 
-          const reactionPromise = meeting.sendReaction('thumbs_down', 'invalid_skin_tone');
+          const reactionPromise = meeting.sendReaction('thumb_down', 'invalid_skin_tone');
 
           assert.exists(reactionPromise.then);
           await reactionPromise;
@@ -5595,7 +6505,7 @@ describe('plugin-meetings', () => {
         it('should send a reaction with default skin tone if none provided', async () => {
           meeting.locusInfo.controls = {reactions: {reactionChannelUrl: 'Fake URL'}};
 
-          const reactionPromise = meeting.sendReaction('thumbs_down');
+          const reactionPromise = meeting.sendReaction('thumb_down');
 
           assert.exists(reactionPromise.then);
           await reactionPromise;
@@ -5674,6 +6584,109 @@ describe('plugin-meetings', () => {
           });
         });
       });
+
+      describe('SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED locus event', () => {
+        let spy;
+
+        beforeEach('setup sinon', () => {
+          spy = sinon.spy();
+        });
+
+        const testEmit = async (muted) => {
+          await meeting.locusInfo.emitScoped(
+            {},
+            LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED,
+            {
+              muted,
+            }
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            sinon.match.instanceOf(Meeting),
+            {
+              file: 'meeting/index',
+              function: 'setUpLocusInfoSelfListener',
+            },
+            muted
+              ? EVENT_TRIGGERS.MEETING_SELF_VIDEO_MUTED_BY_OTHERS
+              : EVENT_TRIGGERS.MEETING_SELF_VIDEO_UNMUTED_BY_OTHERS,
+            {
+              payload: {
+                muted,
+              },
+            }
+          );
+        };
+
+        it('emits the expected event when muted', async () => {
+          await testEmit(true);
+        });
+
+        it('emits the expected event when not muted', async () => {
+          await testEmit(false);
+        });
+      });
+
+      describe('getAnalyzerMetricsPrePayload', () => {
+        it('should have #getAnalyzerMetricsPrePayload', () => {
+          assert.exists(meeting.getAnalyzerMetricsPrePayload);
+        });
+
+        beforeEach(() => {
+          meeting.meetingRequest.getAnalyzerMetricsPrePayload = sinon
+            .stub()
+            .returns(Promise.resolve());
+          meeting.webex.internal = {services: {get: sinon.stub().returns('Locus URL')}};
+          meeting.correlationId = 'correlation-id';
+        });
+
+        it('it should include meetingLookupUrl if provided', () => {
+          const res = meeting.getAnalyzerMetricsPrePayload({
+            meetingLookupUrl: 'https://service-url.com',
+            event: 'client.meetinginfo.response',
+          });
+
+          assert.deepEqual(res.event,  {
+            canProceed: true,
+            eventData: {
+              webClientDomain: '',
+            },
+            identifiers: {
+              correlationId: 'correlation-id',
+              deviceId: uuid3,
+              locusUrl: 'Locus URL',
+              meetingLookupUrl: 'https://service-url.com',
+              orgId: undefined,
+              userId: uuid1,
+            },
+            name: 'client.meetinginfo.response',
+          });
+
+          assert.deepEqual(res.origin, {
+            channel: undefined,
+            loginType: undefined,
+            userType: undefined,
+            clientInfo: {
+              browser: '',
+              browserVersion: '',
+              clientType: undefined,
+              clientVersion: 'webex-js-sdk/undefined',
+              localNetworkPrefix: null,
+              os: 'other',
+              osVersion: getOSVersion() || 'unknown',
+              subClientType: undefined,
+            },
+            name: 'endpoint',
+            networkType: 'unknown',
+            userAgent: 'webex-js-sdk/test-undefined client=undefined; (os=linux/5)',
+          });
+
+          assert.deepEqual(res.senderCountryCode, undefined);
+          assert.deepEqual(res.version, 1);
+
+        });
+      });
     });
   });
 });