@webex/plugin-meetings 3.0.0-beta.3 → 3.0.0-beta.30

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

@@ -22,8 +22,9 @@ import {
   LOCUSINFO,
   PC_BAIL_TIMEOUT,
 } from '@webex/plugin-meetings/src/constants';
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {ConnectionState, Event, Errors, ErrorType, RemoteTrackType} from '@webex/internal-media-core';
 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';
@@ -36,6 +37,8 @@ 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';
@@ -44,13 +47,18 @@ 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 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,
   MeetingNotActiveError,
   UserInLobbyError,
-  NoMediaEstablishedYetError
+  NoMediaEstablishedYetError,
 } from '../../../../src/common/errors/webex-errors';
 import WebExMeetingsErrors from '../../../../src/common/errors/webex-meetings-error';
 import ParameterError from '../../../../src/common/errors/parameter';
@@ -59,11 +67,12 @@ import CaptchaError from '../../../../src/common/errors/captcha-error';
 import IntentToJoinError from '../../../../src/common/errors/intent-to-join';
 import DefaultSDKConfig from '../../../../src/config';
 import testUtils from '../../../utils/testUtils';
-import {MeetingInfoV2CaptchaError, MeetingInfoV2PasswordError} from '../../../../src/meeting-info/meeting-info-v2';
+import {
+  MeetingInfoV2CaptchaError,
+  MeetingInfoV2PasswordError,
+} from '../../../../src/meeting-info/meeting-info-v2';
 
-const {
-  getBrowserName
-} = BrowserDetection();
+const {getBrowserName} = BrowserDetection();
 
 // Non-stubbed function
 const {getDisplayMedia} = Media;
@@ -75,7 +84,7 @@ describe('plugin-meetings', () => {
     error: () => {},
     warn: () => {},
     trace: () => {},
-    debug: () => {}
+    debug: () => {},
   };
 
   beforeEach(() => {
@@ -87,44 +96,48 @@ describe('plugin-meetings', () => {
 
   before(() => {
     const MediaStream = {
-      getVideoTracks: () => [{
-        applyConstraints: () => { }
-      }]
+      getVideoTracks: () => [
+        {
+          applyConstraints: () => {},
+        },
+      ],
     };
 
     Object.defineProperty(global.window.navigator, 'mediaDevices', {
       writable: true,
       value: {
         getDisplayMedia: sinon.stub().returns(Promise.resolve(MediaStream)),
-        enumerateDevices: sinon.stub().returns(Promise.resolve([
-          {
-            deviceId: '',
-            kind: 'audioinput',
-            label: '',
-            groupId: '29d9339cc77bffdd24cb69ee80f6d3200481099bcd0f29267558672de0430777',
-          },
-          {
-            deviceId: '',
-            kind: 'videoinput',
-            label: '',
-            groupId: '08d4f8200e7e4a3425ecf75b7edea9ae4acd934019f2a52217554bcc8e46604d',
-          },
-          {
-            deviceId: '',
-            kind: 'audiooutput',
-            label: '',
-            groupId: '29d9339cc77bffdd24cb69ee80f6d3200481099bcd0f29267558672de0430777',
-          }
-        ])),
+        enumerateDevices: sinon.stub().returns(
+          Promise.resolve([
+            {
+              deviceId: '',
+              kind: 'audioinput',
+              label: '',
+              groupId: '29d9339cc77bffdd24cb69ee80f6d3200481099bcd0f29267558672de0430777',
+            },
+            {
+              deviceId: '',
+              kind: 'videoinput',
+              label: '',
+              groupId: '08d4f8200e7e4a3425ecf75b7edea9ae4acd934019f2a52217554bcc8e46604d',
+            },
+            {
+              deviceId: '',
+              kind: 'audiooutput',
+              label: '',
+              groupId: '29d9339cc77bffdd24cb69ee80f6d3200481099bcd0f29267558672de0430777',
+            },
+          ])
+        ),
         getSupportedConstraints: sinon.stub().returns({
-          sampleRate: true
-        })
+          sampleRate: true,
+        }),
       },
     });
 
     Object.defineProperty(global.window, 'MediaStream', {
       writable: true,
-      value: MediaStream
+      value: MediaStream,
     });
     LoggerConfig.set({verboseEvents: true, enable: false});
     LoggerProxy.set(logger);
@@ -149,32 +162,34 @@ describe('plugin-meetings', () => {
       children: {
         meetings: Meetings,
         credentials: Credentials,
-        support: Support
+        support: Support,
+        llm: LLM,
+        mercury: Mercury,
       },
       config: {
         credentials: {
-          client_id: 'mock-client-id'
+          client_id: 'mock-client-id',
         },
         meetings: {
           reconnection: {
-            enabled: false
+            enabled: false,
           },
           mediaSettings: {},
           metrics: {},
           stats: {},
-          experimental: {enableUnifiedMeetings: true}
+          experimental: {enableUnifiedMeetings: true},
         },
         metrics: {
-          type: ['behavioral']
-        }
-      }
+          type: ['behavioral'],
+        },
+      },
     });
 
     webex.internal.support.submitLogs = sinon.stub().returns(Promise.resolve());
     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();
 
     TriggerProxy.trigger = sinon.stub().returns(true);
     Metrics.postEvent = sinon.stub();
@@ -203,7 +218,7 @@ describe('plugin-meetings', () => {
         destinationType: _MEETING_ID_,
       },
       {
-        parent: webex
+        parent: webex,
       }
     );
 
@@ -246,6 +261,13 @@ 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('#invite', () => {
@@ -432,7 +454,6 @@ describe('plugin-meetings', () => {
           it('should return a promise resolution', async () => {
             meeting.audio = {handleClientRequest};
 
-
             const audio = meeting.unmuteAudio();
 
             assert.exists(audio.then);
@@ -449,8 +470,8 @@ describe('plugin-meetings', () => {
           readyState: 'live',
           enabled: true,
           getSettings: () => ({
-            sampleRate: 48000
-          })
+            sampleRate: 48000,
+          }),
         });
 
         beforeEach(() => {
@@ -458,7 +479,7 @@ describe('plugin-meetings', () => {
           sinon.replace(meeting, 'addMedia', () => {
             sinon.stub(meeting.mediaProperties, 'audioTrack').value(fakeMediaTrack());
             sinon.stub(meeting.mediaProperties, 'mediaDirection').value({
-              receiveAudio: true
+              receiveAudio: true,
             });
           });
         });
@@ -470,7 +491,7 @@ describe('plugin-meetings', () => {
           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');
+                assert.equal(err.toString(), "Error: Meeting doesn't have an audioTrack attached");
               });
             });
           });
@@ -518,7 +539,7 @@ describe('plugin-meetings', () => {
 
             it('should throw no audio error', async () => {
               await meeting.disableBNR().catch((err) => {
-                assert.equal(err.toString(), 'Error: Meeting doesn\'t have an audioTrack attached');
+                assert.equal(err.toString(), "Error: Meeting doesn't have an audioTrack attached");
               });
             });
           });
@@ -650,7 +671,11 @@ describe('plugin-meetings', () => {
       });
       describe('#getMediaStreams', () => {
         beforeEach(() => {
-          sinon.stub(Media, 'getSupportedDevice').callsFake((options) => Promise.resolve({sendAudio: options.sendAudio, sendVideo: options.sendVideo}));
+          sinon
+            .stub(Media, 'getSupportedDevice')
+            .callsFake((options) =>
+              Promise.resolve({sendAudio: options.sendAudio, sendVideo: options.sendVideo})
+            );
           sinon.stub(Media, 'getUserMedia').returns(Promise.resolve(['stream1', 'stream2']));
         });
         afterEach(() => {
@@ -674,17 +699,20 @@ describe('plugin-meetings', () => {
           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
+          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
@@ -709,23 +737,33 @@ describe('plugin-meetings', () => {
             video: {
               width: {
                 max: 400,
-                ideal: 400
+                ideal: 400,
               },
               height: {
                 max: 200,
-                ideal: 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);
+          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});
@@ -759,13 +797,12 @@ 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 {
             await meeting.receiveTranscription();
-          }
-          catch (err) {
+          } catch (err) {
             assert(err, {});
           }
         });
@@ -773,15 +810,74 @@ describe('plugin-meetings', () => {
       describe('#stopReceivingTranscription', () => {
         it('should get invoked', () => {
           meeting.transcription = {
-            closeSocket: sinon.stub()
+            closeSocket: sinon.stub(),
           };
 
           meeting.stopReceivingTranscription();
           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';
 
         beforeEach(() => {
           sandbox = sinon.createSandbox();
@@ -799,22 +895,47 @@ describe('plugin-meetings', () => {
           meeting.setCorrelationId = sinon.stub().returns(true);
           meeting.setLocus = sinon.stub().returns(true);
           webex.meetings.registered = true;
+          meeting.updateLLMConnection = sinon.stub();
         });
         describe('successful', () => {
           beforeEach(() => {
-            sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve());
+            sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(joinMeetingResult));
           });
 
           it('should join the meeting and return promise', async () => {
             const join = meeting.join();
 
-            assert.calledWithMatch(Metrics.postEvent, {event: eventType.CALL_INITIATED, data: {trigger: trigger.USER_INTERACTION, isRoapCallEnabled: true}});
+            assert.calledWithMatch(Metrics.postEvent, {
+              event: eventType.CALL_INITIATED,
+              data: {trigger: trigger.USER_INTERACTION, isRoapCallEnabled: true},
+            });
 
             assert.exists(join.then);
-            await join;
+            const result = await join;
+
             assert.calledOnce(MeetingUtil.joinMeeting);
             assert.calledOnce(meeting.setLocus);
+            assert.equal(result, joinMeetingResult);
+          });
+
+          it('should call updateLLMConnection upon joining if config value is set', async () => {
+            meeting.config.enableAutomaticLLM = true;
+            meeting.webex.internal.llm.on = sinon.stub();
+            meeting.processRelayEvent = sinon.stub();
+            await meeting.join();
+
+            assert.calledOnce(meeting.updateLLMConnection);
+            assert.calledOnceWithExactly(meeting.webex.internal.llm.on, 'event:relay.event', meeting.processRelayEvent);
+          });
+
+          it('should not call updateLLMConnection upon joining if config value is not set', async () => {
+            meeting.webex.internal.llm.on = sinon.stub();
+            await meeting.join();
+
+            assert.notCalled(meeting.updateLLMConnection);
+            assert.notCalled(meeting.webex.internal.llm.on);
           });
+
           it('should invoke `receiveTranscription()` if receiveTranscription is set to true', async () => {
             meeting.isTranscriptionSupported = sinon.stub().returns(true);
             meeting.receiveTranscription = sinon.stub().returns(Promise.resolve());
@@ -856,8 +977,7 @@ describe('plugin-meetings', () => {
               try {
                 await meeting.join();
                 joinSucceeded = true;
-              }
-              catch (e) {
+              } catch (e) {
                 assert.instanceOf(e, IntentToJoinError);
               }
               assert.isFalse(joinSucceeded);
@@ -905,7 +1025,7 @@ describe('plugin-meetings', () => {
       describe('#addMedia', () => {
         const muteStateStub = {
           handleClientRequest: sinon.stub().returns(Promise.resolve(true)),
-          applyClientStateLocally: sinon.stub().returns(Promise.resolve(true))
+          applyClientStateLocally: sinon.stub().returns(Promise.resolve(true)),
         };
 
         let fakeMediaConnection;
@@ -913,7 +1033,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(),
           };
@@ -926,7 +1046,9 @@ describe('plugin-meetings', () => {
           meeting.setMercuryListener = sinon.stub().returns(true);
           meeting.setupMediaConnectionListeners = sinon.stub();
           meeting.setMercuryListener = sinon.stub();
-          meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: {}, turnDiscoverySkippedReason: undefined});
+          meeting.roap.doTurnDiscovery = sinon
+            .stub()
+            .resolves({turnServerInfo: {}, turnDiscoverySkippedReason: undefined});
         });
 
         it('should have #addMedia', () => {
@@ -955,8 +1077,7 @@ describe('plugin-meetings', () => {
           try {
             await meeting.addMedia();
             assert.fail('addMedia should have thrown an exception.');
-          }
-          catch (err) {
+          } catch (err) {
             assert.instanceOf(err, UserInLobbyError);
           }
         });
@@ -974,37 +1095,33 @@ describe('plugin-meetings', () => {
 
           assert.isNull(meeting.statsAnalyzer);
           assert(Metrics.sendBehavioralMetric.calledOnce);
-          assert.calledWith(
-            Metrics.sendBehavioralMetric,
-            BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
-              correlation_id: meeting.correlationId,
-              locus_id: meeting.locusUrl.split('/').pop(),
-              reason: error.message,
-              stack: error.stack,
-              code: error.code,
-              turnDiscoverySkippedReason: undefined,
-              turnServerUsed: true
-            }
-          );
+          assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
+            correlation_id: meeting.correlationId,
+            locus_id: meeting.locusUrl.split('/').pop(),
+            reason: error.message,
+            stack: error.stack,
+            code: error.code,
+            turnDiscoverySkippedReason: undefined,
+            turnServerUsed: true,
+          });
         });
 
         it('checks metrics called with skipped reason config', async () => {
-          meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: 'config'});
+          meeting.roap.doTurnDiscovery = sinon
+            .stub()
+            .resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: 'config'});
           meeting.meetingState = 'ACTIVE';
           await meeting.addMedia().catch((err) => {
             assert.exists(err);
             assert(Metrics.sendBehavioralMetric.calledOnce);
-            assert.calledWith(
-              Metrics.sendBehavioralMetric,
-              BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
-                correlation_id: meeting.correlationId,
-                locus_id: meeting.locusUrl.split('/').pop(),
-                reason: err.message,
-                stack: err.stack,
-                turnDiscoverySkippedReason: 'config',
-                turnServerUsed: false
-              }
-            );
+            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: err.message,
+              stack: err.stack,
+              turnDiscoverySkippedReason: 'config',
+              turnServerUsed: false,
+            });
           });
         });
 
@@ -1023,12 +1140,13 @@ describe('plugin-meetings', () => {
           assert(Metrics.sendBehavioralMetric.calledOnce);
           assert.calledWith(
             Metrics.sendBehavioralMetric,
-            BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, sinon.match({
+            BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE,
+            sinon.match({
               correlation_id: meeting.correlationId,
               locus_id: meeting.locusUrl.split('/').pop(),
               reason: result.message,
               turnDiscoverySkippedReason: undefined,
-              turnServerUsed: true
+              turnServerUsed: true,
             })
           );
         });
@@ -1049,10 +1167,9 @@ describe('plugin-meetings', () => {
 
           try {
             await meeting.addMedia({
-              mediaSettings: {}
+              mediaSettings: {},
             });
-          }
-          catch (err) {
+          } catch (err) {
             assert.fail('should not throw an error');
           }
         });
@@ -1092,11 +1209,13 @@ describe('plugin-meetings', () => {
         });
 
         it('should attach the media and return promise', async () => {
-          meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
+          meeting.roap.doTurnDiscovery = sinon
+            .stub()
+            .resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
 
           meeting.meetingState = 'ACTIVE';
           const media = meeting.addMedia({
-            mediaSettings: {}
+            mediaSettings: {},
           });
 
           assert.exists(media);
@@ -1105,12 +1224,17 @@ describe('plugin-meetings', () => {
           assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false);
           assert.calledOnce(meeting.mediaProperties.setMediaDirection);
           assert.calledOnce(Media.createMediaConnection);
-          assert.calledWith(Media.createMediaConnection, sinon.match.any, sinon.match({turnServerInfo: undefined}));
+          assert.calledWith(
+            Media.createMediaConnection,
+            false,
+            meeting.getMediaConnectionDebugId(),
+            sinon.match({turnServerInfo: undefined})
+          );
           assert.calledOnce(meeting.setMercuryListener);
           assert.calledOnce(fakeMediaConnection.initiateOffer);
           /* statsAnalyzer is initiated inside of addMedia so there isn't
-          * a good way to mock it without mocking the constructor
-          */
+           * a good way to mock it without mocking the constructor
+           */
         });
 
         it('should pass the turn server info to the peer connection', async () => {
@@ -1121,17 +1245,16 @@ describe('plugin-meetings', () => {
           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
+              password: FAKE_TURN_PASSWORD,
             },
-            turnServerSkippedReason: undefined
+            turnServerSkippedReason: undefined,
           });
           const media = meeting.addMedia({
-            mediaSettings: {}
+            mediaSettings: {},
           });
 
           assert.exists(media);
@@ -1139,25 +1262,35 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.roap.doTurnDiscovery);
           assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false);
           assert.calledOnce(Media.createMediaConnection);
-          assert.calledWith(Media.createMediaConnection, sinon.match.any, sinon.match({
-            turnServerInfo: {
-              url: FAKE_TURN_URL,
-              username: FAKE_TURN_USER,
-              password: FAKE_TURN_PASSWORD
-            }
-          }));
+          assert.calledWith(
+            Media.createMediaConnection,
+            false,
+            meeting.getMediaConnectionDebugId(),
+            sinon.match({
+              turnServerInfo: {
+                url: FAKE_TURN_URL,
+                username: FAKE_TURN_USER,
+                password: FAKE_TURN_PASSWORD,
+              },
+            })
+          );
           assert.calledOnce(fakeMediaConnection.initiateOffer);
         });
 
         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: {}
+            mediaSettings: {},
           });
 
-          await clock.tickAsync(4000 /* meetingState timer, hardcoded inside addMedia */ + PC_BAIL_TIMEOUT /* connection state timer */);
+          await clock.tickAsync(
+            4000 /* meetingState timer, hardcoded inside addMedia */ +
+              PC_BAIL_TIMEOUT /* connection state timer */
+          );
           await testUtils.flushPromises();
 
           assert.exists(media);
@@ -1174,9 +1307,10 @@ describe('plugin-meetings', () => {
 
           let errorThrown = false;
 
-          await meeting.addMedia({
-            mediaSettings: {}
-          })
+          await meeting
+            .addMedia({
+              mediaSettings: {},
+            })
             .catch((error) => {
               assert.equal(error.code, IceGatheringFailed.CODE);
               errorThrown = true;
@@ -1188,19 +1322,15 @@ describe('plugin-meetings', () => {
         it('should send ADD_MEDIA_SUCCESS metrics', async () => {
           meeting.meetingState = 'ACTIVE';
           await meeting.addMedia({
-            mediaSettings: {}
+            mediaSettings: {},
           });
 
           assert.calledOnce(Metrics.sendBehavioralMetric);
-          assert.calledWith(
-            Metrics.sendBehavioralMetric,
-            BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS,
-            {
-              correlation_id: meeting.correlationId,
-              locus_id: meeting.locusUrl.split('/').pop(),
-              connectionType: 'udp'
-            }
-          );
+          assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ADD_MEDIA_SUCCESS, {
+            correlation_id: meeting.correlationId,
+            locus_id: meeting.locusUrl.split('/').pop(),
+            connectionType: 'udp',
+          });
         });
 
         describe('handles StatsAnalyzer events', () => {
@@ -1218,7 +1348,7 @@ describe('plugin-meetings', () => {
             sinon.stub(StatsAnalyzerModule, 'StatsAnalyzer').returns(statsAnalyzerStub);
 
             await meeting.addMedia({
-              mediaSettings: {}
+              mediaSettings: {},
             });
           });
 
@@ -1227,51 +1357,79 @@ describe('plugin-meetings', () => {
           });
 
           it('LOCAL_MEDIA_STARTED triggers "meeting:media:local:start" event and sends metrics', async () => {
-            statsAnalyzerStub.emit({file: 'test', function: 'test'}, StatsAnalyzerModule.EVENTS.LOCAL_MEDIA_STARTED, {type: 'audio'});
+            statsAnalyzerStub.emit(
+              {file: 'test', function: 'test'},
+              StatsAnalyzerModule.EVENTS.LOCAL_MEDIA_STARTED,
+              {type: 'audio'}
+            );
 
             assert.calledWith(
               TriggerProxy.trigger,
               sinon.match.instanceOf(Meeting),
               {
                 file: 'meeting/index',
-                function: 'addMedia'
+                function: 'addMedia',
               },
               EVENT_TRIGGERS.MEETING_MEDIA_LOCAL_STARTED,
               {
-                type: 'audio'
+                type: 'audio',
               }
             );
-            assert.calledWithMatch(Metrics.postEvent, {event: eventType.SENDING_MEDIA_START, data: {mediaType: 'audio'}});
+            assert.calledWithMatch(Metrics.postEvent, {
+              event: eventType.SENDING_MEDIA_START,
+              data: {mediaType: 'audio'},
+            });
           });
 
           it('LOCAL_MEDIA_STOPPED triggers the right metrics', async () => {
-            statsAnalyzerStub.emit({file: 'test', function: 'test'}, StatsAnalyzerModule.EVENTS.LOCAL_MEDIA_STOPPED, {type: 'video'});
+            statsAnalyzerStub.emit(
+              {file: 'test', function: 'test'},
+              StatsAnalyzerModule.EVENTS.LOCAL_MEDIA_STOPPED,
+              {type: 'video'}
+            );
 
-            assert.calledWithMatch(Metrics.postEvent, {event: eventType.SENDING_MEDIA_STOP, data: {mediaType: 'video'}});
+            assert.calledWithMatch(Metrics.postEvent, {
+              event: eventType.SENDING_MEDIA_STOP,
+              data: {mediaType: 'video'},
+            });
           });
 
           it('REMOTE_MEDIA_STARTED triggers "meeting:media:remote:start" event and sends metrics', async () => {
-            statsAnalyzerStub.emit({file: 'test', function: 'test'}, StatsAnalyzerModule.EVENTS.REMOTE_MEDIA_STARTED, {type: 'video'});
+            statsAnalyzerStub.emit(
+              {file: 'test', function: 'test'},
+              StatsAnalyzerModule.EVENTS.REMOTE_MEDIA_STARTED,
+              {type: 'video'}
+            );
 
             assert.calledWith(
               TriggerProxy.trigger,
               sinon.match.instanceOf(Meeting),
               {
                 file: 'meeting/index',
-                function: 'addMedia'
+                function: 'addMedia',
               },
               EVENT_TRIGGERS.MEETING_MEDIA_REMOTE_STARTED,
               {
-                type: 'video'
+                type: 'video',
               }
             );
-            assert.calledWithMatch(Metrics.postEvent, {event: eventType.RECEIVING_MEDIA_START, data: {mediaType: 'video'}});
+            assert.calledWithMatch(Metrics.postEvent, {
+              event: eventType.RECEIVING_MEDIA_START,
+              data: {mediaType: 'video'},
+            });
           });
 
           it('REMOTE_MEDIA_STOPPED triggers the right metrics', async () => {
-            statsAnalyzerStub.emit({file: 'test', function: 'test'}, StatsAnalyzerModule.EVENTS.REMOTE_MEDIA_STOPPED, {type: 'audio'});
+            statsAnalyzerStub.emit(
+              {file: 'test', function: 'test'},
+              StatsAnalyzerModule.EVENTS.REMOTE_MEDIA_STOPPED,
+              {type: 'audio'}
+            );
 
-            assert.calledWithMatch(Metrics.postEvent, {event: eventType.RECEIVING_MEDIA_STOP, data: {mediaType: 'audio'}});
+            assert.calledWithMatch(Metrics.postEvent, {
+              event: eventType.RECEIVING_MEDIA_STOP,
+              data: {mediaType: 'audio'},
+            });
           });
 
           it('MEDIA_QUALITY triggers the right metrics', async () => {
@@ -1283,7 +1441,10 @@ describe('plugin-meetings', () => {
               {data: fakeData, networkType: 'wifi'}
             );
 
-            assert.calledWithMatch(Metrics.postEvent, {event: eventType.MEDIA_QUALITY, data: {intervalData: fakeData, networkType: 'wifi'}});
+            assert.calledWithMatch(Metrics.postEvent, {
+              event: eventType.MEDIA_QUALITY,
+              data: {intervalData: fakeData, networkType: 'wifi'},
+            });
           });
         });
       });
@@ -1346,7 +1507,9 @@ describe('plugin-meetings', () => {
           sandbox = sinon.createSandbox();
           meeting.meetingFiniteStateMachine.ring();
           meeting.meetingFiniteStateMachine.join();
-          meeting.meetingRequest.leaveMeeting = sinon.stub().returns(Promise.resolve({body: 'test'}));
+          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());
@@ -1361,6 +1524,7 @@ describe('plugin-meetings', () => {
           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());
 
           // A meeting needs to be joined to leave
           meeting.meetingState = 'ACTIVE';
@@ -1415,7 +1579,7 @@ describe('plugin-meetings', () => {
             correlationId: meeting.correlationId,
             selfId: meeting.selfId,
             resourceId: null,
-            deviceUrl: meeting.deviceUrl
+            deviceUrl: meeting.deviceUrl,
           });
         });
         it('should leave the meeting on the resource', async () => {
@@ -1428,13 +1592,13 @@ describe('plugin-meetings', () => {
             correlationId: meeting.correlationId,
             selfId: meeting.selfId,
             resourceId: meeting.resourceId,
-            deviceUrl: meeting.deviceUrl
+            deviceUrl: meeting.deviceUrl,
           });
         });
       });
-      describe('#share', () => {
-        it('should have #share', () => {
-          assert.exists(meeting.share);
+      describe('#requestScreenShareFloor', () => {
+        it('should have #requestScreenShareFloor', () => {
+          assert.exists(meeting.requestScreenShareFloor);
         });
         beforeEach(() => {
           meeting.locusInfo.mediaShares = [{name: 'content', url: url1}];
@@ -1442,7 +1606,7 @@ describe('plugin-meetings', () => {
           meeting.meetingRequest.changeMeetingFloor = sinon.stub().returns(Promise.resolve());
         });
         it('should send the share', async () => {
-          const share = meeting.share();
+          const share = meeting.requestScreenShareFloor();
 
           assert.exists(share.then);
           await share;
@@ -1455,7 +1619,9 @@ describe('plugin-meetings', () => {
 
         beforeEach(() => {
           _mediaDirection = meeting.mediaProperties.mediaDirection || {};
-          sinon.stub(meeting.mediaProperties, 'mediaDirection').value({sendAudio: true, sendVideo: true, sendShare: false});
+          sinon
+            .stub(meeting.mediaProperties, 'mediaDirection')
+            .value({sendAudio: true, sendVideo: true, sendShare: false});
         });
 
         afterEach(() => {
@@ -1492,7 +1658,11 @@ describe('plugin-meetings', () => {
           it('properly assigns default values', async () => {
             await meeting.shareScreen({sharePreferences: {highFrameRate: true}});
 
-            assert.calledWith(Media.getDisplayMedia, {sendShare: true, sendAudio: false, sharePreferences: {highFrameRate: true}});
+            assert.calledWith(Media.getDisplayMedia, {
+              sendShare: true,
+              sendAudio: false,
+              sharePreferences: {highFrameRate: true},
+            });
           });
         });
 
@@ -1522,18 +1692,21 @@ describe('plugin-meetings', () => {
               sendShare,
               receiveShare,
               stream,
-              skipSignalingCheck: true
+              skipSignalingCheck: true,
             });
 
             assert.notCalled(meeting.canUpdateMedia);
           });
 
-
           it('skips canUpdateMedia() check on contentTracks.onended', () => {
             const {mediaProperties} = meeting;
+            let registeredListener = null;
             const fakeTrack = {
               getSettings: sinon.stub().returns({}),
-              onended: sinon.stub()
+              onended: sinon.stub(),
+              addEventListener: sinon.stub().callsFake((event, listener) => {
+                registeredListener = listener;
+              }),
             };
 
             sandbox.stub(mediaProperties, 'setLocalShareTrack');
@@ -1542,17 +1715,20 @@ describe('plugin-meetings', () => {
             sandbox.stub(meeting, 'stopShare').resolves(true);
             meeting.setLocalShareTrack(fakeTrack);
 
-            fakeTrack.onended();
+            assert.calledOnce(fakeTrack.addEventListener);
+            assert.calledWith(fakeTrack.addEventListener, 'ended', sinon.match.any);
+            assert.isNotNull(registeredListener);
+
+            registeredListener();
 
             assert.calledWith(meeting.stopShare, {skipSignalingCheck: true});
           });
 
-
           it('stopShare accepts and passes along optional parameters', () => {
             const args = {
               abc: 123,
               receiveShare: false,
-              sendShare: false
+              sendShare: false,
             };
 
             sandbox.stub(meeting, 'updateShare').returns(Promise.resolve());
@@ -1577,24 +1753,22 @@ describe('plugin-meetings', () => {
           });
 
           it('handleShareTrackEnded triggers an event', () => {
-            const stream = 'stream';
             const {EVENT_TYPES} = CONSTANTS;
 
             sandbox.stub(meeting, 'stopShare').resolves(true);
 
-            meeting.handleShareTrackEnded(stream);
+            meeting.handleShareTrackEnded();
 
             assert.calledWith(
               TriggerProxy.trigger,
               sinon.match.instanceOf(Meeting),
               {
                 file: 'meeting/index',
-                function: 'handleShareTrackEnded'
+                function: 'handleShareTrackEnded',
               },
               EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
               {
-                stream,
-                type: EVENT_TYPES.LOCAL_SHARE
+                type: EVENT_TYPES.LOCAL_SHARE,
               }
             );
           });
@@ -1607,20 +1781,22 @@ describe('plugin-meetings', () => {
         const {resolution} = config;
         const shareOptions = {
           sendShare: true,
-          sendAudio: false
+          sendAudio: false,
         };
         const fireFoxOptions = {
           audio: false,
           video: {
             audio: shareOptions.sendAudio,
-            video: shareOptions.sendShare
-          }
+            video: shareOptions.sendShare,
+          },
         };
 
         const MediaStream = {
-          getVideoTracks: () => [{
-            applyConstraints: () => {}
-          }]
+          getVideoTracks: () => [
+            {
+              applyConstraints: () => {},
+            },
+          ],
         };
 
         const MediaConstraint = {
@@ -1628,7 +1804,7 @@ describe('plugin-meetings', () => {
           aspectRatio: config.aspectRatio,
           frameRate: config.screenFrameRate,
           width: null,
-          height: null
+          height: null,
         };
 
         const browserConditionalValue = (value) => {
@@ -1644,31 +1820,23 @@ describe('plugin-meetings', () => {
           if (!global.navigator) {
             global.navigator = {
               mediaDevices: {
-                getDisplayMedia: null
-              }
+                getDisplayMedia: null,
+              },
             };
           }
           _getDisplayMedia = global.navigator.mediaDevices.getDisplayMedia;
-          Object.defineProperty(
-            global.navigator.mediaDevices,
-            'getDisplayMedia',
-            {
-              value: sinon.stub().returns(Promise.resolve(MediaStream)),
-              writable: true
-            }
-          );
+          Object.defineProperty(global.navigator.mediaDevices, 'getDisplayMedia', {
+            value: sinon.stub().returns(Promise.resolve(MediaStream)),
+            writable: true,
+          });
         });
 
         after(() => {
           // clean up for browser
-          Object.defineProperty(
-            global.navigator.mediaDevices,
-            'getDisplayMedia',
-            {
-              value: _getDisplayMedia,
-              writable: true
-            }
-          );
+          Object.defineProperty(global.navigator.mediaDevices, 'getDisplayMedia', {
+            value: _getDisplayMedia,
+            writable: true,
+          });
         });
 
         // eslint-disable-next-line max-len
@@ -1680,39 +1848,48 @@ describe('plugin-meetings', () => {
             maxWidth: SHARE_WIDTH,
             maxHeight: SHARE_HEIGHT,
             idealWidth: SHARE_WIDTH,
-            idealHeight: SHARE_HEIGHT
+            idealHeight: SHARE_HEIGHT,
           };
 
           // If sharePreferences.shareConstraints is defined it ignores
           // default SDK config settings
-          getDisplayMedia({
-            ...shareOptions,
-            sharePreferences: {shareConstraints}
-          }, config);
+          getDisplayMedia(
+            {
+              ...shareOptions,
+              sharePreferences: {shareConstraints},
+            },
+            config
+          );
 
           // eslint-disable-next-line no-undef
-          assert.calledWith(navigator.mediaDevices.getDisplayMedia,
+          assert.calledWith(
+            navigator.mediaDevices.getDisplayMedia,
             browserConditionalValue({
               default: {
-                video: {...shareConstraints}
+                video: {...shareConstraints},
               },
               // Firefox is being handled differently
-              firefox: fireFoxOptions
-            }));
+              firefox: fireFoxOptions,
+            })
+          );
         });
 
         // 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);
+          getDisplayMedia(
+            {
+              ...shareOptions,
+              sharePreferences: {
+                highFrameRate: true,
+              },
+            },
+            config
+          );
 
           // eslint-disable-next-line no-undef
-          assert.calledWith(navigator.mediaDevices.getDisplayMedia,
+          assert.calledWith(
+            navigator.mediaDevices.getDisplayMedia,
             browserConditionalValue({
               default: {
                 video: {
@@ -1723,11 +1900,12 @@ describe('plugin-meetings', () => {
                   maxWidth: resolution.maxWidth,
                   maxHeight: resolution.maxHeight,
                   idealWidth: resolution.idealWidth,
-                  idealHeight: resolution.idealHeight
-                }
+                  idealHeight: resolution.idealHeight,
+                },
               },
-              firefox: fireFoxOptions
-            }));
+              firefox: fireFoxOptions,
+            })
+          );
         });
 
         // eslint-disable-next-line max-len
@@ -1736,17 +1914,19 @@ describe('plugin-meetings', () => {
           const {screenResolution} = config;
 
           // eslint-disable-next-line no-undef
-          assert.calledWith(navigator.mediaDevices.getDisplayMedia,
+          assert.calledWith(
+            navigator.mediaDevices.getDisplayMedia,
             browserConditionalValue({
               default: {
                 video: {
                   ...MediaConstraint,
                   width: screenResolution.idealWidth,
-                  height: screenResolution.idealHeight
-                }
+                  height: screenResolution.idealHeight,
+                },
               },
-              firefox: fireFoxOptions
-            }));
+              firefox: fireFoxOptions,
+            })
+          );
         });
 
         // Test screenResolution
@@ -1759,14 +1939,15 @@ describe('plugin-meetings', () => {
               maxWidth: SHARE_WIDTH,
               maxHeight: SHARE_HEIGHT,
               idealWidth: SHARE_WIDTH,
-              idealHeight: SHARE_HEIGHT
-            }
+              idealHeight: SHARE_HEIGHT,
+            },
           };
 
           getDisplayMedia(shareOptions, customConfig);
 
           // eslint-disable-next-line no-undef
-          assert.calledWith(navigator.mediaDevices.getDisplayMedia,
+          assert.calledWith(
+            navigator.mediaDevices.getDisplayMedia,
             browserConditionalValue({
               default: {
                 video: {
@@ -1776,11 +1957,12 @@ describe('plugin-meetings', () => {
                   maxWidth: SHARE_WIDTH,
                   maxHeight: SHARE_HEIGHT,
                   idealWidth: SHARE_WIDTH,
-                  idealHeight: SHARE_HEIGHT
-                }
+                  idealHeight: SHARE_HEIGHT,
+                },
               },
-              firefox: fireFoxOptions
-            }));
+              firefox: fireFoxOptions,
+            })
+          );
         });
 
         // Test screenFrameRate
@@ -1793,14 +1975,15 @@ describe('plugin-meetings', () => {
               maxWidth: SHARE_WIDTH,
               maxHeight: SHARE_HEIGHT,
               idealWidth: SHARE_WIDTH,
-              idealHeight: SHARE_HEIGHT
-            }
+              idealHeight: SHARE_HEIGHT,
+            },
           };
 
           getDisplayMedia(shareOptions, customConfig);
 
           // eslint-disable-next-line no-undef
-          assert.calledWith(navigator.mediaDevices.getDisplayMedia,
+          assert.calledWith(
+            navigator.mediaDevices.getDisplayMedia,
             browserConditionalValue({
               default: {
                 video: {
@@ -1811,11 +1994,12 @@ describe('plugin-meetings', () => {
                   maxWidth: SHARE_WIDTH,
                   maxHeight: SHARE_HEIGHT,
                   idealWidth: SHARE_WIDTH,
-                  idealHeight: SHARE_HEIGHT
-                }
+                  idealHeight: SHARE_HEIGHT,
+                },
               },
-              firefox: fireFoxOptions
-            }));
+              firefox: fireFoxOptions,
+            })
+          );
         });
       });
 
@@ -1857,22 +2041,35 @@ describe('plugin-meetings', () => {
                 receiveVideo: true,
                 receiveShare: true,
               };
-              meeting.mediaProperties.webrtcMediaConnection = {updateSendReceiveOptions: sinon.stub()};
+              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'
-                }
-              });
-            }));
+            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();
@@ -1892,7 +2089,7 @@ describe('plugin-meetings', () => {
 
           meeting.locusInfo.self = {
             enableDTMF: true,
-            url: url2
+            url: url2,
           };
 
           await meeting.sendDTMF(tones);
@@ -1900,7 +2097,7 @@ describe('plugin-meetings', () => {
           assert.calledWith(meeting.meetingRequest.sendDTMF, {
             locusUrl: meeting.locusInfo.self.url,
             deviceUrl: meeting.deviceUrl,
-            tones
+            tones,
           });
         });
 
@@ -1914,7 +2111,7 @@ describe('plugin-meetings', () => {
           it('should throw an error', () => {
             meeting.locusInfo.self = {
               enableDTMF: false,
-              url: url2
+              url: url2,
             };
 
             assert.isRejected(meeting.sendDTMF('123'));
@@ -1938,8 +2135,8 @@ describe('plugin-meetings', () => {
           screenshareVideo: {
             id: 'fake share track',
             getSettings: sinon.stub().returns({}),
+            addEventListener: sinon.stub()
           },
-
         };
 
         beforeEach(() => {
@@ -1971,21 +2168,22 @@ describe('plugin-meetings', () => {
             receiveVideo: true,
             sendShare: true,
             receiveShare: true,
-            isSharing: true
+            isSharing: true,
           };
 
           sandbox.stub(meeting, 'canUpdateMedia').returns(false);
           meeting.mediaProperties.webrtcMediaConnection = {
-            updateSendReceiveOptions: sinon.stub().resolves({})
+            updateSendReceiveOptions: sinon.stub().resolves({}),
           };
 
           let myPromiseResolved = false;
 
-          meeting.updateMedia({
-            localStream: mockLocalStream,
-            localShare: mockLocalShare,
-            mediaSettings
-          })
+          meeting
+            .updateMedia({
+              localStream: mockLocalStream,
+              localShare: mockLocalShare,
+              mediaSettings,
+            })
             .then(() => {
               myPromiseResolved = true;
             });
@@ -2002,63 +2200,255 @@ describe('plugin-meetings', () => {
 
           // and check that updateSendReceiveOptions is called with the original args
           assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
-          assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions, {
-            send: {
-              audio: FAKE_TRACKS.audio,
-              video: FAKE_TRACKS.video,
-              screenShareVideo: FAKE_TRACKS.screenshareVideo,
-            },
-            receive: {
-              audio: true,
-              video: true,
-              screenShareVideo: true,
-              remoteQualityLevel: 'HIGH'
+          assert.calledWith(
+            meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions,
+            {
+              send: {
+                audio: FAKE_TRACKS.audio,
+                video: FAKE_TRACKS.video,
+                screenShareVideo: FAKE_TRACKS.screenshareVideo,
+              },
+              receive: {
+                audio: true,
+                video: true,
+                screenShareVideo: true,
+                remoteQualityLevel: 'HIGH',
+              },
             }
-          });
+          );
           assert.isTrue(myPromiseResolved);
         });
-      });
 
-      describe('#changeVideoLayout', () => {
-        describe('when media direction has recieve video and there is remoteStream', () => {
-          let mediaDirection;
-          const layoutTypeSingle = 'Single';
+        it('should request floor only after roap transaction is completed', async () => {
+          const eventListeners = {};
 
-          beforeEach(() => {
-            mediaDirection = {
-              sendAudio: true,
-              sendVideo: true,
-              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().returns({mockTrack: 'mockTrack'});
+          meeting.webex.meetings.reachability = {
+            isAnyClusterReachable: sandbox.stub().resolves(true)
+          };
 
-            meeting.meetingRequest.changeVideoLayoutDebounced = sinon.stub().returns(Promise.resolve());
+          const fakeMediaConnection = {
+            close: sinon.stub(),
+            getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+            initiateOffer: sinon.stub().resolves({}),
 
-            meeting.locusInfo.self = {
-              url: url2
-            };
-          });
+            // mock the on() method and store all the listeners
+            on: sinon.stub().callsFake((event, listener) => {
+              eventListeners[event] = listener;
+            }),
+
+            updateSendReceiveOptions: sinon.stub().callsFake(() => {
+              // trigger ROAP_STARTED before updateSendReceiveOptions() resolves
+              if (eventListeners[Event.ROAP_STARTED]) {
+                eventListeners[Event.ROAP_STARTED]();
+              } else {
+                throw new Error('ROAP_STARTED listener not registered')
+              }
+              return Promise.resolve();
+            }),
+          };
 
-          it('should listen once for CONTROLS_MEETING_LAYOUT_UPDATED', async () => {
-            // const spy = sinon.spy(TriggerProxy, 'trigger');
-            const spy = sinon.spy(meeting.locusInfo, 'once');
+          meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
+          meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
+          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
 
-            await meeting.changeVideoLayout('Equal');
+          const requestScreenShareFloorStub = sandbox.stub(meeting, 'requestScreenShareFloor').resolves({});
 
-            assert.calledWith(spy, LOCUSINFO.EVENTS.CONTROLS_MEETING_LAYOUT_UPDATED);
-          });
+          let myPromiseResolved = false;
 
-          it('should have receiveVideo true and remote video track should exist', () => {
-            assert.equal(meeting.mediaProperties.mediaDirection.receiveVideo, true);
-            assert.exists(meeting.mediaProperties.remoteVideoTrack);
+          meeting.meetingState = 'ACTIVE';
+          await meeting.addMedia({
+            mediaSettings: {},
           });
 
-          it('has layoutType which exists in the list of allowed layoutTypes and should call meetingRequest changeVideoLayoutDebounced method', async () => {
-            const layoutType = 'Equal';
+          meeting
+            .updateMedia({
+              localShare: mockLocalShare,
+              mediaSettings: {
+                sendShare: true,
+              },
+            })
+            .then(() => {
+              myPromiseResolved = true;
+            });
+
+          await testUtils.flushPromises();
+
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+          assert.isFalse(myPromiseResolved);
+
+          // verify that requestScreenShareFloorStub was not called yet
+          assert.notCalled(requestScreenShareFloorStub);
+
+          eventListeners[Event.ROAP_DONE]();
+          await testUtils.flushPromises();
+
+          // now it should have been called
+          assert.calledOnce(requestScreenShareFloorStub);
+        });
+      });
+
+      describe('#updateShare', () => {
+        const mockLocalShare = {id: 'mock local share stream'};
+        let eventListeners;
+        let fakeMediaConnection;
+        let requestScreenShareFloorStub;
+
+        const FAKE_TRACKS = {
+          screenshareVideo: {
+            id: 'fake share track',
+            getSettings: sinon.stub().returns({}),
+            addEventListener: sinon.stub(),
+          },
+        };
+
+        beforeEach(async () => {
+          eventListeners = {};
+
+          sinon.stub(MeetingUtil, 'getTrack').callsFake((stream) => {
+            if (stream === mockLocalShare) {
+              return {audioTrack: null, videoTrack: FAKE_TRACKS.screenshareVideo};
+            }
+
+            return {audioTrack: null, videoTrack: null};
+          });
+
+          meeting.webex.meetings.reachability = {
+            isAnyClusterReachable: sinon.stub().resolves(true)
+          };
+
+          fakeMediaConnection = {
+            close: sinon.stub(),
+            getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+            initiateOffer: sinon.stub().resolves({}),
+
+            // mock the on() method and store all the listeners
+            on: sinon.stub().callsFake((event, listener) => {
+              eventListeners[event] = listener;
+            }),
+
+            updateSendReceiveOptions: sinon.stub().callsFake(() => {
+              // trigger ROAP_STARTED before updateSendReceiveOptions() resolves
+              if (eventListeners[Event.ROAP_STARTED]) {
+                eventListeners[Event.ROAP_STARTED]();
+              } else {
+                throw new Error('ROAP_STARTED listener not registered')
+              }
+              return Promise.resolve();
+            }),
+          };
+
+          meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
+          meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
+          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
+
+          requestScreenShareFloorStub = sinon.stub(meeting, 'requestScreenShareFloor').resolves({});
+
+          meeting.meetingState = 'ACTIVE';
+          await meeting.addMedia({
+            mediaSettings: {},
+          });
+        });
+
+        afterEach(() => {
+          sinon.restore();
+        });
+
+        it('when starting share, it should request floor only after roap transaction is completed', async () => {
+          let myPromiseResolved = false;
+
+          meeting
+            .updateShare({
+              sendShare: true,
+              receiveShare: true,
+              stream: mockLocalShare,
+            })
+            .then(() => {
+              myPromiseResolved = true;
+            });
+
+          await testUtils.flushPromises();
+
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+          assert.isFalse(myPromiseResolved);
+
+          // verify that requestScreenShareFloorStub was not called yet
+          assert.notCalled(requestScreenShareFloorStub);
+
+          eventListeners[Event.ROAP_DONE]();
+          await testUtils.flushPromises();
+
+          // now it should have been called
+          assert.calledOnce(requestScreenShareFloorStub);
+        });
+
+        it('when changing screen share stream and no roap transaction happening, it requests floor immediately', async () => {
+          let myPromiseResolved = false;
+
+          // simulate a case when no roap transaction is triggered by updateSendReceiveOptions
+          meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions = sinon.stub().resolves({});
+
+          meeting
+            .updateShare({
+              sendShare: true,
+              receiveShare: true,
+              stream: mockLocalShare,
+            })
+            .then(() => {
+              myPromiseResolved = true;
+            });
+
+          await testUtils.flushPromises();
+
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+          assert.calledOnce(requestScreenShareFloorStub);
+          assert.isTrue(myPromiseResolved);
+        });
+      });
+
+      describe('#changeVideoLayout', () => {
+        describe('when media direction has recieve video and there is remoteStream', () => {
+          let mediaDirection;
+          const layoutTypeSingle = 'Single';
+
+          beforeEach(() => {
+            mediaDirection = {
+              sendAudio: true,
+              sendVideo: true,
+              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()
+              .returns({mockTrack: 'mockTrack'});
+
+            meeting.meetingRequest.changeVideoLayoutDebounced = sinon
+              .stub()
+              .returns(Promise.resolve());
+
+            meeting.locusInfo.self = {
+              url: url2,
+            };
+          });
+
+          it('should listen once for CONTROLS_MEETING_LAYOUT_UPDATED', async () => {
+            // const spy = sinon.spy(TriggerProxy, 'trigger');
+            const spy = sinon.spy(meeting.locusInfo, 'once');
+
+            await meeting.changeVideoLayout('Equal');
+
+            assert.calledWith(spy, LOCUSINFO.EVENTS.CONTROLS_MEETING_LAYOUT_UPDATED);
+          });
+
+          it('should have receiveVideo true and remote video track should exist', () => {
+            assert.equal(meeting.mediaProperties.mediaDirection.receiveVideo, true);
+            assert.exists(meeting.mediaProperties.remoteVideoTrack);
+          });
+
+          it('has layoutType which exists in the list of allowed layoutTypes and should call meetingRequest changeVideoLayoutDebounced method', async () => {
+            const layoutType = 'Equal';
 
             await meeting.changeVideoLayout(layoutType);
 
@@ -2068,11 +2458,11 @@ describe('plugin-meetings', () => {
               deviceUrl: meeting.deviceUrl,
               layoutType,
               main: undefined,
-              content: undefined
+              content: undefined,
             });
           });
 
-          it('doesn\'t have layoutType which exists in the list of allowed layoutTypes should throw an error', async () => {
+          it("doesn't have layoutType which exists in the list of allowed layoutTypes should throw an error", async () => {
             const layoutType = 'Invalid Layout';
 
             assert.isRejected(meeting.changeVideoLayout(layoutType));
@@ -2086,12 +2476,14 @@ describe('plugin-meetings', () => {
               deviceUrl: meeting.deviceUrl,
               layoutType: undefined,
               main: {width: 100, height: 200},
-              content: undefined
+              content: undefined,
             });
           });
 
           it('throws if trying to send renderInfo for content when not receiving content', async () => {
-            assert.isRejected(meeting.changeVideoLayout(layoutTypeSingle, {content: {width: 1280, height: 720}}));
+            assert.isRejected(
+              meeting.changeVideoLayout(layoutTypeSingle, {content: {width: 1280, height: 720}})
+            );
           });
 
           it('calls changeVideoLayoutDebounced with renderInfo for main and content', async () => {
@@ -2103,7 +2495,7 @@ describe('plugin-meetings', () => {
               deviceUrl: meeting.deviceUrl,
               layoutType: layoutTypeSingle,
               main: {width: 100, height: 200},
-              content: undefined
+              content: undefined,
             });
 
             meeting.mediaProperties.mediaDirection.receiveShare = true;
@@ -2117,18 +2509,21 @@ describe('plugin-meetings', () => {
               deviceUrl: meeting.deviceUrl,
               layoutType: layoutTypeSingle,
               main: {width: 100, height: 200},
-              content: {width: 500, height: 600}
+              content: {width: 500, height: 600},
             });
 
             // and now call with both
-            await meeting.changeVideoLayout(layoutTypeSingle, {main: {width: 300, height: 400}, content: {width: 700, height: 800}});
+            await meeting.changeVideoLayout(layoutTypeSingle, {
+              main: {width: 300, height: 400},
+              content: {width: 700, height: 800},
+            });
 
             assert.calledWith(meeting.meetingRequest.changeVideoLayoutDebounced, {
               locusUrl: meeting.locusInfo.self.url,
               deviceUrl: meeting.deviceUrl,
               layoutType: layoutTypeSingle,
               main: {width: 300, height: 400},
-              content: {width: 700, height: 800}
+              content: {width: 700, height: 800},
             });
 
             // and now set just the layoutType, the previous main and content values should be used
@@ -2141,7 +2536,7 @@ describe('plugin-meetings', () => {
               deviceUrl: meeting.deviceUrl,
               layoutType,
               main: {width: 300, height: 400},
-              content: {width: 700, height: 800}
+              content: {width: 700, height: 800},
             });
           });
 
@@ -2153,7 +2548,7 @@ describe('plugin-meetings', () => {
               deviceUrl: meeting.deviceUrl,
               layoutType: layoutTypeSingle,
               main: {width: 1024, height: 768},
-              content: undefined
+              content: undefined,
             });
             meeting.meetingRequest.changeVideoLayoutDebounced.resetHistory();
 
@@ -2175,28 +2570,39 @@ describe('plugin-meetings', () => {
             meeting.mediaProperties.mediaDirection.receiveShare = true;
             meeting.mediaProperties.remoteShare = sinon.stub().returns({mockTrack: 'mockTrack'});
 
-            await meeting.changeVideoLayout(layoutTypeSingle, {main: {width: 500, height: 510}, content: {width: 1024, height: 768}});
+            await meeting.changeVideoLayout(layoutTypeSingle, {
+              main: {width: 500, height: 510},
+              content: {width: 1024, height: 768},
+            });
 
             assert.calledWith(meeting.meetingRequest.changeVideoLayoutDebounced, {
               locusUrl: meeting.locusInfo.self.url,
               deviceUrl: meeting.deviceUrl,
               layoutType: layoutTypeSingle,
               main: {width: 500, height: 510},
-              content: {width: 1024, height: 768}
+              content: {width: 1024, height: 768},
             });
             meeting.meetingRequest.changeVideoLayoutDebounced.resetHistory();
 
             // now send main with width/height different by just 2px - it should be ignored
-            await meeting.changeVideoLayout(layoutTypeSingle, {content: {width: 1026, height: 768}});
+            await meeting.changeVideoLayout(layoutTypeSingle, {
+              content: {width: 1026, height: 768},
+            });
             assert.notCalled(meeting.meetingRequest.changeVideoLayoutDebounced);
 
-            await meeting.changeVideoLayout(layoutTypeSingle, {content: {width: 1022, height: 768}});
+            await meeting.changeVideoLayout(layoutTypeSingle, {
+              content: {width: 1022, height: 768},
+            });
             assert.notCalled(meeting.meetingRequest.changeVideoLayoutDebounced);
 
-            await meeting.changeVideoLayout(layoutTypeSingle, {content: {width: 1024, height: 770}});
+            await meeting.changeVideoLayout(layoutTypeSingle, {
+              content: {width: 1024, height: 770},
+            });
             assert.notCalled(meeting.meetingRequest.changeVideoLayoutDebounced);
 
-            await meeting.changeVideoLayout(layoutTypeSingle, {content: {width: 1024, height: 766}});
+            await meeting.changeVideoLayout(layoutTypeSingle, {
+              content: {width: 1024, height: 766},
+            });
             assert.notCalled(meeting.meetingRequest.changeVideoLayoutDebounced);
           });
 
@@ -2204,14 +2610,17 @@ describe('plugin-meetings', () => {
             meeting.mediaProperties.mediaDirection.receiveShare = true;
             meeting.mediaProperties.remoteShare = sinon.stub().returns({mockTrack: 'mockTrack'});
 
-            await meeting.changeVideoLayout(layoutTypeSingle, {main: {width: 500.5, height: 510.09}, content: {width: 1024.2, height: 768.85}});
+            await meeting.changeVideoLayout(layoutTypeSingle, {
+              main: {width: 500.5, height: 510.09},
+              content: {width: 1024.2, height: 768.85},
+            });
 
             assert.calledWith(meeting.meetingRequest.changeVideoLayoutDebounced, {
               locusUrl: meeting.locusInfo.self.url,
               deviceUrl: meeting.deviceUrl,
               layoutType: layoutTypeSingle,
               main: {width: 501, height: 510},
-              content: {width: 1024, height: 769}
+              content: {width: 1024, height: 769},
             });
           });
         });
@@ -2223,7 +2632,7 @@ describe('plugin-meetings', () => {
             sendAudio: true,
             sendVideo: true,
             sendShare: false,
-            receiveVideo: true
+            receiveVideo: true,
           };
 
           meeting.mediaProperties.mediaDirection = mediaDirection;
@@ -2237,7 +2646,7 @@ describe('plugin-meetings', () => {
             sendAudio: true,
             sendVideo: true,
             sendShare: false,
-            receiveVideo: false
+            receiveVideo: false,
           };
 
           meeting.mediaProperties.mediaDirection = mediaDirection;
@@ -2251,8 +2660,8 @@ describe('plugin-meetings', () => {
 
         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';
+          '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};
@@ -2268,34 +2677,36 @@ describe('plugin-meetings', () => {
           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('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);
-            });
+          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('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']);
-            });
+          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', () => {
@@ -2321,13 +2732,15 @@ describe('plugin-meetings', () => {
           assert.exists(meeting.setRemoteQualityLevel);
         });
 
-        it('should set mediaProperty with the proper level', () => meeting.setRemoteQualityLevel(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
-          assert.equal(meeting.mediaProperties.remoteQualityLevel, CONSTANTS.QUALITY_LEVELS.LOW);
-        }));
+        it('should set mediaProperty with the proper level', () =>
+          meeting.setRemoteQualityLevel(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
+            assert.equal(meeting.mediaProperties.remoteQualityLevel, CONSTANTS.QUALITY_LEVELS.LOW);
+          }));
 
-        it('should call updateMedia', () => meeting.setRemoteQualityLevel(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
-          assert.calledOnce(meeting.updateMedia);
-        }));
+        it('should call updateMedia', () =>
+          meeting.setRemoteQualityLevel(CONSTANTS.QUALITY_LEVELS.LOW).then(() => {
+            assert.calledOnce(meeting.updateMedia);
+          }));
 
         it('should error if set to a invalid level', () => {
           assert.isRejected(meeting.setRemoteQualityLevel('invalid'));
@@ -2341,8 +2754,12 @@ describe('plugin-meetings', () => {
 
       describe('#usePhoneAudio', () => {
         beforeEach(() => {
-          meeting.meetingRequest.dialIn = sinon.stub().returns(Promise.resolve({body: {locus: 'testData'}}));
-          meeting.meetingRequest.dialOut = sinon.stub().returns(Promise.resolve({body: {locus: 'testData'}}));
+          meeting.meetingRequest.dialIn = sinon
+            .stub()
+            .returns(Promise.resolve({body: {locus: 'testData'}}));
+          meeting.meetingRequest.dialOut = sinon
+            .stub()
+            .returns(Promise.resolve({body: {locus: 'testData'}}));
           meeting.locusInfo.onFullLocus = sinon.stub().returns(Promise.resolve());
         });
 
@@ -2354,7 +2771,7 @@ describe('plugin-meetings', () => {
             correlationId: meeting.correlationId,
             dialInUrl: DIAL_IN_URL,
             locusUrl: meeting.locusUrl,
-            clientUrl: meeting.deviceUrl
+            clientUrl: meeting.deviceUrl,
           });
           assert.calledWith(meeting.locusInfo.onFullLocus, 'testData');
           assert.notCalled(meeting.meetingRequest.dialOut);
@@ -2369,7 +2786,7 @@ describe('plugin-meetings', () => {
             correlationId: meeting.correlationId,
             dialInUrl: DIAL_IN_URL,
             locusUrl: meeting.locusUrl,
-            clientUrl: meeting.deviceUrl
+            clientUrl: meeting.deviceUrl,
           });
           assert.calledWith(meeting.locusInfo.onFullLocus, 'testData');
           assert.notCalled(meeting.meetingRequest.dialOut);
@@ -2386,7 +2803,7 @@ describe('plugin-meetings', () => {
             dialOutUrl: DIAL_OUT_URL,
             locusUrl: meeting.locusUrl,
             clientUrl: meeting.deviceUrl,
-            phoneNumber
+            phoneNumber,
           });
           assert.calledWith(meeting.locusInfo.onFullLocus, 'testData');
           assert.notCalled(meeting.meetingRequest.dialIn);
@@ -2402,7 +2819,7 @@ describe('plugin-meetings', () => {
             dialOutUrl: DIAL_OUT_URL,
             locusUrl: meeting.locusUrl,
             clientUrl: meeting.deviceUrl,
-            phoneNumber
+            phoneNumber,
           });
           assert.calledWith(meeting.locusInfo.onFullLocus, 'testData');
           assert.notCalled(meeting.meetingRequest.dialIn);
@@ -2413,11 +2830,14 @@ describe('plugin-meetings', () => {
 
           meeting.meetingRequest.dialIn = sinon.stub().returns(Promise.reject(error));
 
-          return meeting.usePhoneAudio().then(() => Promise.reject(new Error('Promise resolved when it should have rejected'))).catch((e) => {
-            assert.equal(e, error);
+          return meeting
+            .usePhoneAudio()
+            .then(() => Promise.reject(new Error('Promise resolved when it should have rejected')))
+            .catch((e) => {
+              assert.equal(e, error);
 
-            return Promise.resolve();
-          });
+              return Promise.resolve();
+            });
         });
 
         it('rejects if the request failed (dial out)', async () => {
@@ -2425,11 +2845,14 @@ describe('plugin-meetings', () => {
 
           meeting.meetingRequest.dialOut = sinon.stub().returns(Promise.reject(error));
 
-          return meeting.usePhoneAudio('+441234567890').then(() => Promise.reject(new Error('Promise resolved when it should have rejected'))).catch((e) => {
-            assert.equal(e, error);
+          return meeting
+            .usePhoneAudio('+441234567890')
+            .then(() => Promise.reject(new Error('Promise resolved when it should have rejected')))
+            .catch((e) => {
+              assert.equal(e, error);
 
-            return Promise.resolve();
-          });
+              return Promise.resolve();
+            });
         });
       });
 
@@ -2448,34 +2871,42 @@ describe('plugin-meetings', () => {
           locusUrl: 'some_locus_url',
           sipUrl: 'some_sip_url', // or sipMeetingUri
           meetingNumber: '123456', // this.config.experimental.enableUnifiedMeetings
-          hostId: 'some_host_id' // this.owner;
+          hostId: 'some_host_id', // this.owner;
         };
         const FAKE_SDK_CAPTCHA_INFO = {
           captchaId: FAKE_CAPTCHA_ID,
           verificationImageURL: FAKE_CAPTCHA_IMAGE_URL,
           verificationAudioURL: FAKE_CAPTCHA_AUDIO_URL,
-          refreshURL: FAKE_CAPTCHA_REFRESH_URL
+          refreshURL: FAKE_CAPTCHA_REFRESH_URL,
         };
         const FAKE_WBXAPPAPI_CAPTCHA_INFO = {
           captchaID: `${FAKE_CAPTCHA_ID}-2`,
           verificationImageURL: `${FAKE_CAPTCHA_IMAGE_URL}-2`,
           verificationAudioURL: `${FAKE_CAPTCHA_AUDIO_URL}-2`,
-          refreshURL: `${FAKE_CAPTCHA_REFRESH_URL}-2`
+          refreshURL: `${FAKE_CAPTCHA_REFRESH_URL}-2`,
         };
 
-
         it('calls meetingInfoProvider with all the right parameters and parses the result', async () => {
-          meeting.attrs.meetingInfoProvider = {fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO})};
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO}),
+          };
           meeting.requiredCaptcha = FAKE_SDK_CAPTCHA_INFO;
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
           meeting.parseMeetingInfo = sinon.stub().returns(undefined);
 
           await meeting.fetchMeetingInfo({
-            password: FAKE_PASSWORD, captchaCode: FAKE_CAPTCHA_CODE
+            password: FAKE_PASSWORD,
+            captchaCode: FAKE_CAPTCHA_CODE,
           });
 
-          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, FAKE_PASSWORD, {code: FAKE_CAPTCHA_CODE, id: FAKE_CAPTCHA_ID});
+          assert.calledWith(
+            meeting.attrs.meetingInfoProvider.fetchMeetingInfo,
+            FAKE_DESTINATION,
+            FAKE_TYPE,
+            FAKE_PASSWORD,
+            {code: FAKE_CAPTCHA_CODE, id: FAKE_CAPTCHA_ID}
+          );
 
           assert.calledWith(meeting.parseMeetingInfo, {body: FAKE_MEETING_INFO}, FAKE_DESTINATION);
           assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
@@ -2483,11 +2914,18 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
           assert.equal(meeting.requiredCaptcha, null);
           assert.calledTwice(TriggerProxy.trigger);
-          assert.calledWith(TriggerProxy.trigger, meeting, {file: 'meetings', function: 'fetchMeetingInfo'}, 'meeting:meetingInfoAvailable');
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meetings', function: 'fetchMeetingInfo'},
+            'meeting:meetingInfoAvailable'
+          );
         });
 
         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})};
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO}),
+          };
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
           meeting.parseMeetingInfo = sinon.stub().returns(undefined);
@@ -2504,7 +2942,13 @@ describe('plugin-meetings', () => {
           assert.isUndefined(meeting.fetchMeetingInfoTimeoutId);
 
           // meeting info provider
-          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, null, null);
+          assert.calledWith(
+            meeting.attrs.meetingInfoProvider.fetchMeetingInfo,
+            FAKE_DESTINATION,
+            FAKE_TYPE,
+            null,
+            null
+          );
 
           // parseMeeting info
           assert.calledWith(meeting.parseMeetingInfo, {body: FAKE_MEETING_INFO}, FAKE_DESTINATION);
@@ -2515,31 +2959,48 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.NOT_REQUIRED);
 
           assert.calledTwice(TriggerProxy.trigger);
-          assert.calledWith(TriggerProxy.trigger, meeting, {file: 'meetings', function: 'fetchMeetingInfo'}, 'meeting:meetingInfoAvailable');
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meetings', function: 'fetchMeetingInfo'},
+            'meeting:meetingInfoAvailable'
+          );
         });
 
         it('fails if captchaCode is provided when captcha not needed', async () => {
-          meeting.attrs.meetingInfoProvider = {fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO})};
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO}),
+          };
           meeting.requiredCaptcha = null;
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
 
-          await assert.isRejected(meeting.fetchMeetingInfo({
-            captchaCode: FAKE_CAPTCHA_CODE
-          }), Error, 'fetchMeetingInfo() called with captchaCode when captcha was not required');
+          await assert.isRejected(
+            meeting.fetchMeetingInfo({
+              captchaCode: FAKE_CAPTCHA_CODE,
+            }),
+            Error,
+            'fetchMeetingInfo() called with captchaCode when captcha was not required'
+          );
 
           assert.notCalled(meeting.attrs.meetingInfoProvider.fetchMeetingInfo);
         });
 
         it('fails if password is provided when not required', async () => {
-          meeting.attrs.meetingInfoProvider = {fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO})};
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO}),
+          };
           meeting.passwordStatus = PASSWORD_STATUS.NOT_REQUIRED;
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
 
-          await assert.isRejected(meeting.fetchMeetingInfo({
-            password: FAKE_PASSWORD
-          }), Error, 'fetchMeetingInfo() called with password when password was not required');
+          await assert.isRejected(
+            meeting.fetchMeetingInfo({
+              password: FAKE_PASSWORD,
+            }),
+            Error,
+            'fetchMeetingInfo() called with password when password was not required'
+          );
 
           assert.notCalled(meeting.attrs.meetingInfoProvider.fetchMeetingInfo);
         });
@@ -2548,15 +3009,26 @@ describe('plugin-meetings', () => {
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
           meeting.attrs.meetingInfoProvider = {
-            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2PasswordError(403004, FAKE_MEETING_INFO))
+            fetchMeetingInfo: sinon
+              .stub()
+              .throws(new MeetingInfoV2PasswordError(403004, FAKE_MEETING_INFO)),
           };
 
           await assert.isRejected(meeting.fetchMeetingInfo({}), PasswordError);
 
-          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, null, null);
+          assert.calledWith(
+            meeting.attrs.meetingInfoProvider.fetchMeetingInfo,
+            FAKE_DESTINATION,
+            FAKE_TYPE,
+            null,
+            null
+          );
 
           assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
-          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
+          assert.equal(
+            meeting.meetingInfoFailureReason,
+            MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD
+          );
           assert.equal(meeting.requiredCaptcha, null);
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
         });
@@ -2565,25 +3037,38 @@ describe('plugin-meetings', () => {
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
           meeting.attrs.meetingInfoProvider = {
-            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO))
+            fetchMeetingInfo: sinon
+              .stub()
+              .throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO)),
           };
           meeting.requiredCaptcha = null;
 
-          await assert.isRejected(meeting.fetchMeetingInfo({
-            password: 'aaa'
-          }), CaptchaError);
-
-          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', null);
+          await assert.isRejected(
+            meeting.fetchMeetingInfo({
+              password: 'aaa',
+            }),
+            CaptchaError
+          );
 
+          assert.calledWith(
+            meeting.attrs.meetingInfoProvider.fetchMeetingInfo,
+            FAKE_DESTINATION,
+            FAKE_TYPE,
+            'aaa',
+            null
+          );
 
           assert.deepEqual(meeting.meetingInfo, {});
-          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
+          assert.equal(
+            meeting.meetingInfoFailureReason,
+            MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD
+          );
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
           assert.deepEqual(meeting.requiredCaptcha, {
             captchaId: FAKE_CAPTCHA_ID,
             verificationImageURL: FAKE_CAPTCHA_IMAGE_URL,
             verificationAudioURL: FAKE_CAPTCHA_AUDIO_URL,
-            refreshURL: FAKE_CAPTCHA_REFRESH_URL
+            refreshURL: FAKE_CAPTCHA_REFRESH_URL,
           });
         });
 
@@ -2591,15 +3076,27 @@ describe('plugin-meetings', () => {
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
           meeting.attrs.meetingInfoProvider = {
-            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO))
+            fetchMeetingInfo: sinon
+              .stub()
+              .throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO)),
           };
           meeting.requiredCaptcha = FAKE_SDK_CAPTCHA_INFO;
 
-          await assert.isRejected(meeting.fetchMeetingInfo({
-            password: 'aaa', captchaCode: 'bbb'
-          }), CaptchaError);
+          await assert.isRejected(
+            meeting.fetchMeetingInfo({
+              password: 'aaa',
+              captchaCode: 'bbb',
+            }),
+            CaptchaError
+          );
 
-          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', {code: 'bbb', id: FAKE_CAPTCHA_ID});
+          assert.calledWith(
+            meeting.attrs.meetingInfoProvider.fetchMeetingInfo,
+            FAKE_DESTINATION,
+            FAKE_TYPE,
+            'aaa',
+            {code: 'bbb', id: FAKE_CAPTCHA_ID}
+          );
 
           assert.deepEqual(meeting.meetingInfo, {});
           assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA);
@@ -2611,20 +3108,24 @@ describe('plugin-meetings', () => {
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
           meeting.attrs.meetingInfoProvider = {
-            fetchMeetingInfo: sinon.stub().resolves(
-              {
-                statusCode: 200,
-                body: FAKE_MEETING_INFO
-              }
-            )
+            fetchMeetingInfo: sinon.stub().resolves({
+              statusCode: 200,
+              body: FAKE_MEETING_INFO,
+            }),
           };
           meeting.passwordStatus = PASSWORD_STATUS.REQUIRED;
 
           await meeting.fetchMeetingInfo({
-            password: 'aaa'
+            password: 'aaa',
           });
 
-          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', null);
+          assert.calledWith(
+            meeting.attrs.meetingInfoProvider.fetchMeetingInfo,
+            FAKE_DESTINATION,
+            FAKE_TYPE,
+            'aaa',
+            null
+          );
 
           assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
           assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
@@ -2638,36 +3139,50 @@ describe('plugin-meetings', () => {
           const refreshedCaptcha = {
             captchaID: FAKE_WBXAPPAPI_CAPTCHA_INFO.captchaID,
             verificationImageURL: FAKE_WBXAPPAPI_CAPTCHA_INFO.verificationImageURL,
-            verificationAudioURL: FAKE_WBXAPPAPI_CAPTCHA_INFO.verificationAudioURL
+            verificationAudioURL: FAKE_WBXAPPAPI_CAPTCHA_INFO.verificationAudioURL,
           };
 
           meeting.attrs.meetingInfoProvider = {
-            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2PasswordError(403004, FAKE_MEETING_INFO))
+            fetchMeetingInfo: sinon
+              .stub()
+              .throws(new MeetingInfoV2PasswordError(403004, FAKE_MEETING_INFO)),
           };
-          meeting.meetingRequest.refreshCaptcha = sinon.stub().returns(Promise.resolve(
-            {
-              body: refreshedCaptcha
-            }
-          ));
+          meeting.meetingRequest.refreshCaptcha = sinon.stub().returns(
+            Promise.resolve({
+              body: refreshedCaptcha,
+            })
+          );
           meeting.passwordStatus = PASSWORD_STATUS.REQUIRED;
           meeting.requiredCaptcha = FAKE_SDK_CAPTCHA_INFO;
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
 
-          await assert.isRejected(meeting.fetchMeetingInfo({
-            password: 'aaa', captchaCode: 'bbb'
-          }));
+          await assert.isRejected(
+            meeting.fetchMeetingInfo({
+              password: 'aaa',
+              captchaCode: 'bbb',
+            })
+          );
 
-          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', {code: 'bbb', id: FAKE_CAPTCHA_ID});
+          assert.calledWith(
+            meeting.attrs.meetingInfoProvider.fetchMeetingInfo,
+            FAKE_DESTINATION,
+            FAKE_TYPE,
+            'aaa',
+            {code: 'bbb', id: FAKE_CAPTCHA_ID}
+          );
 
           assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
-          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
+          assert.equal(
+            meeting.meetingInfoFailureReason,
+            MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD
+          );
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
           assert.deepEqual(meeting.requiredCaptcha, {
             captchaId: refreshedCaptcha.captchaID,
             verificationImageURL: refreshedCaptcha.verificationImageURL,
             verificationAudioURL: refreshedCaptcha.verificationAudioURL,
-            refreshURL: FAKE_SDK_CAPTCHA_INFO.refreshURL // refresh url doesn't change
+            refreshURL: FAKE_SDK_CAPTCHA_INFO.refreshURL, // refresh url doesn't change
           });
         });
       });
@@ -2677,48 +3192,56 @@ describe('plugin-meetings', () => {
           assert.isRejected(meeting.refreshCaptcha(), Error);
         });
         it('sends correct request to captcha service refresh url', async () => {
-          const REFRESH_URL = 'https://something.webex.com/captchaservice/v1/captchas/refresh?blablabla=something&captchaID=xxx';
-          const EXPECTED_REFRESH_URL = 'https://something.webex.com/captchaservice/v1/captchas/refresh?blablabla=something&captchaID=xxx&siteFullName=something.webex.com';
+          const REFRESH_URL =
+            'https://something.webex.com/captchaservice/v1/captchas/refresh?blablabla=something&captchaID=xxx';
+          const EXPECTED_REFRESH_URL =
+            'https://something.webex.com/captchaservice/v1/captchas/refresh?blablabla=something&captchaID=xxx&siteFullName=something.webex.com';
 
           const FAKE_SDK_CAPTCHA_INFO = {
             captchaId: 'some id',
             verificationImageURL: 'some image url',
             verificationAudioURL: 'some audio url',
-            refreshURL: REFRESH_URL
+            refreshURL: REFRESH_URL,
           };
 
           const FAKE_REFRESHED_CAPTCHA = {
             captchaID: 'some id',
             verificationImageURL: 'some image url',
-            verificationAudioURL: 'some audio url'
+            verificationAudioURL: 'some audio url',
           };
 
           // setup the meeting so that a captcha is required
           meeting.attrs.meetingInfoProvider = {
-            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO))
+            fetchMeetingInfo: sinon
+              .stub()
+              .throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO)),
           };
 
-          await assert.isRejected(meeting.fetchMeetingInfo({
-            password: ''
-          }), CaptchaError);
+          await assert.isRejected(
+            meeting.fetchMeetingInfo({
+              password: '',
+            }),
+            CaptchaError
+          );
 
           assert.deepEqual(meeting.requiredCaptcha, FAKE_SDK_CAPTCHA_INFO);
-          meeting.meetingRequest.refreshCaptcha = sinon.stub().returns(Promise.resolve({body: FAKE_REFRESHED_CAPTCHA}));
+          meeting.meetingRequest.refreshCaptcha = sinon
+            .stub()
+            .returns(Promise.resolve({body: FAKE_REFRESHED_CAPTCHA}));
 
           // test the captcha refresh
           await meeting.refreshCaptcha();
 
-          assert.calledWith(meeting.meetingRequest.refreshCaptcha,
-            {
-              captchaRefreshUrl: EXPECTED_REFRESH_URL,
-              captchaId: FAKE_SDK_CAPTCHA_INFO.captchaId
-            });
+          assert.calledWith(meeting.meetingRequest.refreshCaptcha, {
+            captchaRefreshUrl: EXPECTED_REFRESH_URL,
+            captchaId: FAKE_SDK_CAPTCHA_INFO.captchaId,
+          });
 
           assert.deepEqual(meeting.requiredCaptcha, {
             captchaId: FAKE_REFRESHED_CAPTCHA.captchaID,
             verificationImageURL: FAKE_REFRESHED_CAPTCHA.verificationImageURL,
             verificationAudioURL: FAKE_REFRESHED_CAPTCHA.verificationAudioURL,
-            refreshURL: FAKE_SDK_CAPTCHA_INFO.refreshURL // refresh url doesn't change
+            refreshURL: FAKE_SDK_CAPTCHA_INFO.refreshURL, // refresh url doesn't change
           });
         });
       });
@@ -2732,7 +3255,7 @@ describe('plugin-meetings', () => {
           assert(Metrics.sendBehavioralMetric.calledOnce);
           assert.calledWith(
             Metrics.sendBehavioralMetric,
-            BEHAVIORAL_METRICS.VERIFY_PASSWORD_SUCCESS,
+            BEHAVIORAL_METRICS.VERIFY_PASSWORD_SUCCESS
           );
           assert.equal(result.isPasswordValid, true);
           assert.equal(result.requiredCaptcha, null);
@@ -2807,7 +3330,9 @@ describe('plugin-meetings', () => {
           sandbox = sinon.createSandbox();
           meeting.meetingFiniteStateMachine.ring();
           meeting.meetingFiniteStateMachine.join();
-          meeting.meetingRequest.endMeetingForAll = sinon.stub().returns(Promise.resolve({body: 'test'}));
+          meeting.meetingRequest.endMeetingForAll = sinon
+            .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());
@@ -2821,6 +3346,7 @@ describe('plugin-meetings', () => {
           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());
 
           // A meeting needs to be joined to end
           meeting.meetingState = 'ACTIVE';
@@ -2859,7 +3385,11 @@ describe('plugin-meetings', () => {
           sandbox.stub(meeting.mediaProperties, 'unsetMediaTracks');
 
           sandbox.stub(meeting.reconnectionManager, 'reconnectMedia').returns(Promise.resolve());
-          sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(MeetingUtil.parseLocusJoin({body: {locus, mediaConnections: []}})));
+          sandbox
+            .stub(MeetingUtil, 'joinMeeting')
+            .returns(
+              Promise.resolve(MeetingUtil.parseLocusJoin({body: {locus, mediaConnections: []}}))
+            );
         });
 
         afterEach(() => {
@@ -2870,8 +3400,7 @@ describe('plugin-meetings', () => {
         it('should throw an error if resourceId not passed', async () => {
           try {
             await meeting.moveTo();
-          }
-          catch (err) {
+          } catch (err) {
             assert.instanceOf(err, ParameterError);
             assert.equal(err.sdkMessage, 'Cannot move call without a resourceId.');
           }
@@ -2888,17 +3417,17 @@ describe('plugin-meetings', () => {
                   share: true,
                   share_audio: false,
                   video: false,
-                  whiteboard: false
+                  whiteboard: false,
                 },
                 tx: {
                   audio: false,
                   share: false,
                   share_audio: false,
                   video: false,
-                  whiteboard: false
-                }
-              }
-            }
+                  whiteboard: false,
+                },
+              },
+            },
           });
           assert.calledWithMatch(Metrics.postEvent, {event: eventType.MOVE_MEDIA});
         });
@@ -2907,17 +3436,19 @@ describe('plugin-meetings', () => {
           sinon.spy(MeetingUtil, 'joinMeetingOptions');
           await meeting.moveTo('resourceId');
 
-          assert.calledWith(MeetingUtil.joinMeetingOptions, meeting, {resourceId: 'resourceId', moveToResource: true});
+          assert.calledWith(MeetingUtil.joinMeetingOptions, meeting, {
+            resourceId: 'resourceId',
+            moveToResource: true,
+          });
         });
 
         it('should reconnectMedia after DX joins after moveTo', async () => {
           await meeting.moveTo('resourceId');
 
-
           await meeting.locusInfo.emitScoped(
             {
               file: 'locus-info',
-              function: 'updateSelf'
+              function: 'updateSelf',
             },
             'SELF_OBSERVING'
           );
@@ -2933,36 +3464,30 @@ describe('plugin-meetings', () => {
           assert.called(meeting.mediaProperties.setMediaDirection);
           assert.called(meeting.mediaProperties.unsetMediaTracks);
 
-          assert.calledWith(meeting.reconnectionManager.reconnectMedia,
-            {
-              mediaDirection: {
-                sendVideo: false,
-                receiveVideo: false,
-                sendAudio: false,
-                receiveAudio: false,
-                sendShare: false,
-                receiveShare: true
-              }
-            });
+          assert.calledWith(meeting.reconnectionManager.reconnectMedia, {
+            mediaDirection: {
+              sendVideo: false,
+              receiveVideo: false,
+              sendAudio: false,
+              receiveAudio: false,
+              sendShare: false,
+              receiveShare: true,
+            },
+          });
         });
 
         it('should throw an error if moveTo call fails', async () => {
           MeetingUtil.joinMeeting = sinon.stub().returns(Promise.reject());
           try {
             await meeting.moveTo('resourceId');
-          }
-          catch {
+          } catch {
             assert.calledOnce(Metrics.sendBehavioralMetric);
-            assert.calledWith(
-              Metrics.sendBehavioralMetric,
-              BEHAVIORAL_METRICS.MOVE_TO_FAILURE,
-              {
-                correlation_id: meeting.correlationId,
-                locus_id: meeting.locusUrl.split('/').pop(),
-                reason: sinon.match.any,
-                stack: sinon.match.any
-              }
-            );
+            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.MOVE_TO_FAILURE, {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: sinon.match.any,
+              stack: sinon.match.any,
+            });
           }
           Metrics.sendBehavioralMetric.reset();
           meeting.reconnectionManager.reconnectMedia = sinon.stub().returns(Promise.reject());
@@ -2972,23 +3497,18 @@ describe('plugin-meetings', () => {
             await meeting.locusInfo.emitScoped(
               {
                 file: 'locus-info',
-                function: 'updateSelf'
+                function: 'updateSelf',
               },
               'SELF_OBSERVING'
             );
-          }
-          catch {
+          } catch {
             assert.calledOnce(Metrics.sendBehavioralMetric);
-            assert.calledWith(
-              Metrics.sendBehavioralMetric,
-              BEHAVIORAL_METRICS.MOVE_TO_FAILURE,
-              {
-                correlation_id: meeting.correlationId,
-                locus_id: meeting.locusUrl.split('/').pop(),
-                reason: sinon.match.any,
-                stack: sinon.match.any
-              }
-            );
+            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.MOVE_TO_FAILURE, {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: sinon.match.any,
+              stack: sinon.match.any,
+            });
           }
         });
       });
@@ -2998,7 +3518,11 @@ describe('plugin-meetings', () => {
 
         beforeEach(() => {
           sandbox = sinon.createSandbox();
-          sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(MeetingUtil.parseLocusJoin({body: {locus, mediaConnections: []}})));
+          sandbox
+            .stub(MeetingUtil, 'joinMeeting')
+            .returns(
+              Promise.resolve(MeetingUtil.parseLocusJoin({body: {locus, mediaConnections: []}}))
+            );
           sandbox.stub(MeetingUtil, 'leaveMeeting').returns(Promise.resolve());
         });
 
@@ -3010,8 +3534,7 @@ describe('plugin-meetings', () => {
         it('should throw an error if resourceId not passed', async () => {
           try {
             await meeting.moveFrom();
-          }
-          catch (err) {
+          } catch (err) {
             assert.instanceOf(err, ParameterError);
 
             assert.equal(err.sdkMessage, 'Cannot move call without a resourceId.');
@@ -3032,35 +3555,193 @@ describe('plugin-meetings', () => {
           assert.calledWith(MeetingUtil.leaveMeeting, meeting, {
             resourceId: 'resourceId',
             correlationId: meeting.correlationId,
-            moveMeeting: true
+            moveMeeting: true,
           });
 
           assert.calledOnce(Metrics.sendBehavioralMetric);
-          assert.calledWith(
-            Metrics.sendBehavioralMetric,
-            BEHAVIORAL_METRICS.MOVE_FROM_SUCCESS,
-          );
+          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 {
+          } 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
-              }
-            );
+            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;
+
+        beforeEach(() => {
+          audioTrack = {
+            id: 'audio track',
+            getSettings: sinon.stub().returns({}),
+          };
+          videoTrack = {
+            id: 'video track',
+            getSettings: sinon.stub().returns({}),
+          };
+          videoShareTrack = {
+            id: 'share track',
+            addEventListener: sinon.stub(),
+            removeEventListener: sinon.stub(),
+            getSettings: sinon.stub().returns({}),
+          };
+          meeting.requestScreenShareFloor = sinon.stub().resolves({});
+          meeting.releaseScreenShareFloor = sinon.stub().resolves({});
+          meeting.mediaProperties.mediaDirection = {sendAudio: false, sendVideo: false, sendShare: false};
+          meeting.mediaProperties.webrtcMediaConnection = {
+            publishTrack: sinon.stub().resolves({}),
+            unpublishTrack: sinon.stub().resolves({}),
+          };
+
+          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 = () => {
+            assert.calledWith(createMuteStateStub, 'audio', meeting, meeting.mediaProperties.mediaDirection);
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, audioTrack, 'main');
+            assert.equal(meeting.mediaProperties.audioTrack, audioTrack);
+            assert.equal(meeting.mediaProperties.mediaDirection.sendAudio, true);
           }
+
+          const checkVideoPublished = () => {
+            assert.calledWith(createMuteStateStub, 'video', meeting, meeting.mediaProperties.mediaDirection);
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, videoTrack, 'main');
+            assert.equal(meeting.mediaProperties.videoTrack, videoTrack);
+            assert.equal(meeting.mediaProperties.mediaDirection.sendVideo, true);
+          }
+
+          const checkScreenShareVideoPublished = () => {
+            assert.calledOnce(meeting.requestScreenShareFloor);
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.publishTrack, videoShareTrack, 'slides');
+            assert.equal(meeting.mediaProperties.shareTrack, videoShareTrack);
+            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();
+          });
+
+          it('creates MuteState instance and publishes the track for main audio', async () => {
+            await meeting.publishTracks({microphone: audioTrack});
+
+            assert.calledOnce(createMuteStateStub);
+            assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
+            checkAudioPublished();
+          });
+
+          it('creates MuteState instance and publishes the track for main video', async () => {
+            await meeting.publishTracks({camera: videoTrack});
+
+            assert.calledOnce(createMuteStateStub);
+            assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
+            checkVideoPublished();
+          });
+
+          it('publishes audio, video and screen share together', async () => {
+            await meeting.publishTracks({
+              microphone: audioTrack,
+              camera: videoTrack,
+              screenShare: {
+                video: videoShareTrack,
+              }
+            });
+
+            assert.calledTwice(createMuteStateStub);
+            assert.calledThrice(meeting.mediaProperties.webrtcMediaConnection.publishTrack);
+            checkAudioPublished();
+            checkVideoPublished();
+            checkScreenShareVideoPublished();
+          })
         });
+
+        describe('unpublishTracks', () => {
+          beforeEach(async () => {
+            await meeting.publishTracks({
+              microphone: audioTrack,
+              camera: videoTrack,
+              screenShare: {video: videoShareTrack}
+            });
+          });
+
+          const checkAudioUnpublished = () => {
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, audioTrack, 'main');
+
+            assert.equal(meeting.mediaProperties.audioTrack, null);
+            assert.equal(meeting.mediaProperties.mediaDirection.sendAudio, false);
+          };
+
+          const checkVideoUnpublished = () => {
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, videoTrack, 'main');
+
+            assert.equal(meeting.mediaProperties.videoTrack, null);
+            assert.equal(meeting.mediaProperties.mediaDirection.sendVideo, false);
+          }
+
+          const checkScreenShareVideoUnpublished = () => {
+            assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack, videoShareTrack, 'slides');
+
+            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.calledOnce(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack);
+            checkVideoUnpublished();
+          })
+
+          it('un-publishes the screen share video track correctly', async () => {
+            await meeting.unpublishTracks([videoShareTrack]);
+
+            assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.unpublishTrack);
+            checkScreenShareVideoUnpublished();
+          })
+        })
       });
     });
 
@@ -3127,7 +3808,9 @@ describe('plugin-meetings', () => {
             meeting.config.reconnection.enabled = true;
             meeting.currentMediaStatus = {audio: true};
             meeting.reconnectionManager = new ReconnectionManager(meeting);
-            meeting.reconnectionManager.reconnect = sinon.stub().returns(Promise.reject(new Error()));
+            meeting.reconnectionManager.reconnect = sinon
+              .stub()
+              .returns(Promise.reject(new Error()));
             meeting.reconnectionManager.reset = sinon.stub().returns(true);
           });
 
@@ -3152,7 +3835,7 @@ describe('plugin-meetings', () => {
                 correlation_id: meeting.correlationId,
                 locus_id: meeting.locusUrl.split('/').pop(),
                 reason: sinon.match.any,
-                stack: sinon.match.any
+                stack: sinon.match.any,
               }
             );
           });
@@ -3164,7 +3847,7 @@ describe('plugin-meetings', () => {
               sinon.match.instanceOf(Meeting),
               {file: 'meeting/index', function: 'reconnect'},
               EVENTS.REQUEST_UPLOAD_LOGS,
-              sinon.match.instanceOf(Meeting),
+              sinon.match.instanceOf(Meeting)
             );
           });
 
@@ -3241,6 +3924,7 @@ describe('plugin-meetings', () => {
       });
       describe('#setLocalShareTrack', () => {
         it('should trigger a media:ready event with local share stream', () => {
+          let registeredListener = null;
           const track = {
             getSettings: sinon.stub().returns({
               aspectRatio: '1.7',
@@ -3248,16 +3932,17 @@ describe('plugin-meetings', () => {
               height: 1980,
               width: 1080,
               displaySurface: true,
-              cursor: true
-            })
+              cursor: true,
+            }),
+            addEventListener: sinon.stub().callsFake((event, listener) => {
+              registeredListener = listener;
+            }),
           };
-          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);
+          meeting.setLocalShareTrack(track);
           assert.calledTwice(TriggerProxy.trigger);
           assert.calledWith(
             TriggerProxy.trigger,
@@ -3267,7 +3952,8 @@ describe('plugin-meetings', () => {
           );
           assert.calledOnce(meeting.mediaProperties.setLocalShareTrack);
           assert.equal(meeting.mediaProperties.localStream, undefined);
-          meeting.mediaProperties.shareTrack.onended();
+          assert.isNotNull(registeredListener);
+          registeredListener();
           assert.calledOnce(meeting.stopShare);
         });
       });
@@ -3281,33 +3967,51 @@ describe('plugin-meetings', () => {
             // mock the on() method and store all the listeners
             on: sinon.stub().callsFake((event, listener) => {
               eventListeners[event] = listener;
-            })
+            }),
           };
         });
 
         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]({track: 'track', type: MC.RemoteTrackType.AUDIO});
+          eventListeners[Event.REMOTE_TRACK_ADDED]({
+            track: 'track',
+            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});
+          assert.deepEqual(TriggerProxy.trigger.getCall(1).args[3], {
+            type: 'remoteAudio',
+            stream: true,
+          });
 
-          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({track: 'track', type: MC.RemoteTrackType.VIDEO});
+          eventListeners[Event.REMOTE_TRACK_ADDED]({
+            track: 'track',
+            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});
+          assert.deepEqual(TriggerProxy.trigger.getCall(2).args[3], {
+            type: 'remoteVideo',
+            stream: true,
+          });
 
-          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({track: 'track', type: MC.RemoteTrackType.SCREENSHARE_VIDEO});
+          eventListeners[Event.REMOTE_TRACK_ADDED]({
+            track: 'track',
+            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});
+          assert.deepEqual(TriggerProxy.trigger.getCall(3).args[3], {
+            type: 'remoteShare',
+            stream: true,
+          });
         });
 
         describe('should send correct metrics for ROAP_FAILURE event', () => {
@@ -3321,10 +4025,19 @@ describe('plugin-meetings', () => {
 
           const checkMetricSent = (event) => {
             assert.calledOnce(Metrics.postEvent);
-            assert.calledWithMatch(Metrics.postEvent, {event, meetingId: meeting.id, data: {canProceed: false}});
+            assert.calledWithMatch(Metrics.postEvent, {
+              event,
+              meetingId: meeting.id,
+              data: {canProceed: false},
+            });
           };
 
-          const checkBehavioralMetricSent = (metricName, expectedCode, expectedReason, expectedMetadataType) => {
+          const checkBehavioralMetricSent = (
+            metricName,
+            expectedCode,
+            expectedReason,
+            expectedMetadataType
+          ) => {
             assert.calledOnce(Metrics.sendBehavioralMetric);
             assert.calledWith(
               Metrics.sendBehavioralMetric,
@@ -3333,65 +4046,101 @@ describe('plugin-meetings', () => {
                 code: expectedCode,
                 correlation_id: meeting.correlationId,
                 reason: expectedReason,
-                stack: sinon.match.any
+                stack: sinon.match.any,
               },
               {
-                type: expectedMetadataType
+                type: expectedMetadataType,
               }
             );
           };
 
           it('should send metrics for SdpOfferCreationError error', () => {
-            const fakeError = new MC.Errors.SdpOfferCreationError(fakeErrorMessage, {name: fakeErrorName, cause: {name: fakeRootCauseName}});
+            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, fakeErrorMessage, fakeRootCauseName);
+            checkBehavioralMetricSent(
+              BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE,
+              Errors.ErrorCode.SdpOfferCreationError,
+              fakeErrorMessage,
+              fakeRootCauseName
+            );
           });
 
           it('should send metrics for SdpOfferHandlingError error', () => {
-            const fakeError = new MC.Errors.SdpOfferHandlingError(fakeErrorMessage, {name: fakeErrorName, cause: {name: fakeRootCauseName}});
+            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, fakeErrorMessage, fakeRootCauseName);
+            checkBehavioralMetricSent(
+              BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE,
+              Errors.ErrorCode.SdpOfferHandlingError,
+              fakeErrorMessage,
+              fakeRootCauseName
+            );
           });
 
           it('should send metrics for SdpAnswerHandlingError error', () => {
-            const fakeError = new MC.Errors.SdpAnswerHandlingError(fakeErrorMessage, {name: fakeErrorName, cause: {name: fakeRootCauseName}});
+            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, fakeErrorMessage, fakeRootCauseName);
+            checkBehavioralMetricSent(
+              BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE,
+              Errors.ErrorCode.SdpAnswerHandlingError,
+              fakeErrorMessage,
+              fakeRootCauseName
+            );
           });
 
           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, fakeErrorMessage, fakeErrorName);
+            checkBehavioralMetricSent(
+              BEHAVIORAL_METRICS.INVALID_ICE_CANDIDATE,
+              Errors.ErrorCode.SdpError,
+              fakeErrorMessage,
+              fakeErrorName
+            );
           });
 
           it('should send metrics for IceGatheringError error', () => {
             // IceGatheringError is usually without a cause
-            const fakeError = new MC.Errors.IceGatheringError(fakeErrorMessage, {name: fakeErrorName});
+            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, fakeErrorMessage, fakeErrorName);
+            checkBehavioralMetricSent(
+              BEHAVIORAL_METRICS.INVALID_ICE_CANDIDATE,
+              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;
@@ -3399,7 +4148,9 @@ describe('plugin-meetings', () => {
 
           beforeEach(() => {
             sendRoapOKStub = sinon.stub(meeting.roap, 'sendRoapOK').resolves({});
-            sendRoapMediaRequestStub = sinon.stub(meeting.roap, 'sendRoapMediaRequest').resolves({});
+            sendRoapMediaRequestStub = sinon
+              .stub(meeting.roap, 'sendRoapMediaRequest')
+              .resolves({});
             sendRoapAnswerStub = sinon.stub(meeting.roap, 'sendRoapAnswer').resolves({});
             sendRoapErrorStub = sinon.stub(meeting.roap, 'sendRoapError').resolves({});
 
@@ -3407,106 +4158,140 @@ describe('plugin-meetings', () => {
           });
 
           it('handles OK message correctly', () => {
-            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({roapMessage: {messageType: 'OK', seq: 1}});
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
+              roapMessage: {messageType: 'OK', seq: 1},
+            });
 
             assert.calledOnce(Metrics.postEvent);
-            assert.calledWithMatch(Metrics.postEvent, {event: eventType.REMOTE_SDP_RECEIVED, meetingId: meeting.id});
+            assert.calledWithMatch(Metrics.postEvent, {
+              event: eventType.REMOTE_SDP_RECEIVED,
+              meetingId: meeting.id,
+            });
 
             assert.calledOnce(sendRoapOKStub);
-            assert.calledWith(sendRoapOKStub, {seq: 1, mediaId: meeting.mediaId, correlationId: meeting.correlationId});
+            assert.calledWith(sendRoapOKStub, {
+              seq: 1,
+              mediaId: meeting.mediaId,
+              correlationId: meeting.correlationId,
+            });
           });
 
           it('handles OFFER message correctly', () => {
-            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {
                 messageType: 'OFFER',
                 seq: 1,
                 sdp: 'fake sdp',
                 tieBreaker: 12345,
-              }
+              },
             });
 
             assert.calledOnce(Metrics.postEvent);
-            assert.calledWithMatch(Metrics.postEvent, {event: eventType.LOCAL_SDP_GENERATED, meetingId: meeting.id});
+            assert.calledWithMatch(Metrics.postEvent, {
+              event: eventType.LOCAL_SDP_GENERATED,
+              meetingId: meeting.id,
+            });
 
             assert.calledOnce(sendRoapMediaRequestStub);
             assert.calledWith(sendRoapMediaRequestStub, {
-              seq: 1, sdp: 'fake sdp', tieBreaker: 12345, meeting, reconnect: false
+              seq: 1,
+              sdp: 'fake sdp',
+              tieBreaker: 12345,
+              meeting,
+              reconnect: false,
             });
           });
 
           it('handles ANSWER message correctly', () => {
-            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {
                 messageType: 'ANSWER',
                 seq: 10,
                 sdp: 'fake sdp answer',
                 tieBreaker: 12345,
-              }
+              },
             });
 
             assert.calledOnce(Metrics.postEvent);
-            assert.calledWithMatch(Metrics.postEvent, {event: eventType.REMOTE_SDP_RECEIVED, meetingId: meeting.id});
+            assert.calledWithMatch(Metrics.postEvent, {
+              event: eventType.REMOTE_SDP_RECEIVED,
+              meetingId: meeting.id,
+            });
 
             assert.calledOnce(sendRoapAnswerStub);
             assert.calledWith(sendRoapAnswerStub, {
-              seq: 10, sdp: 'fake sdp answer', mediaId: meeting.mediaId, correlationId: meeting.correlationId
+              seq: 10,
+              sdp: 'fake sdp answer',
+              mediaId: meeting.mediaId,
+              correlationId: meeting.correlationId,
             });
           });
 
           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,
                 sdp: 'fake sdp answer',
                 tieBreaker: 12345,
-              }
+              },
             });
             await testUtils.flushPromises();
 
             assert.calledOnce(Metrics.sendBehavioralMetric);
-            assert.calledWithMatch(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ROAP_ANSWER_FAILURE, {
-              correlation_id: meeting.correlationId,
-              locus_id: meeting.locusUrl.split('/').pop(),
-              reason: 'sending answer failed'
-            });
+            assert.calledWithMatch(
+              Metrics.sendBehavioralMetric,
+              BEHAVIORAL_METRICS.ROAP_ANSWER_FAILURE,
+              {
+                correlation_id: meeting.correlationId,
+                locus_id: meeting.locusUrl.split('/').pop(),
+                reason: 'sending answer failed',
+              }
+            );
           });
 
-          [MC.ErrorType.CONFLICT, MC.ErrorType.DOUBLECONFLICT].forEach((errorType) =>
+          [ErrorType.CONFLICT, ErrorType.DOUBLECONFLICT].forEach((errorType) =>
             it(`handles ERROR message indicating glare condition correctly (errorType=${errorType})`, () => {
-              eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+              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.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
+                seq: 10,
+                errorType,
+                mediaId: meeting.mediaId,
+                correlationId: meeting.correlationId,
               });
-            }));
+            })
+          );
 
           it('handles ERROR message indicating other errors correctly', () => {
-            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+            eventListeners[Event.ROAP_MESSAGE_TO_SEND]({
               roapMessage: {
                 messageType: 'ERROR',
                 seq: 10,
-                errorType: MC.ErrorType.FAILED,
+                errorType: ErrorType.FAILED,
                 tieBreaker: 12345,
-              }
+              },
             });
 
             assert.notCalled(Metrics.sendBehavioralMetric);
@@ -3514,9 +4299,9 @@ describe('plugin-meetings', () => {
             assert.calledOnce(sendRoapErrorStub);
             assert.calledWith(sendRoapErrorStub, {
               seq: 10,
-              errorType: MC.ErrorType.FAILED,
+              errorType: ErrorType.FAILED,
               mediaId: meeting.mediaId,
-              correlationId: meeting.correlationId
+              correlationId: meeting.correlationId,
             });
           });
         });
@@ -3550,6 +4335,83 @@ describe('plugin-meetings', () => {
           );
           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
+          );
+        });
+      });
+
+      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
+          );
+        });
+      });
+
+      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
+          );
+        });
       });
 
       describe('#setUpLocusUrlListener', () => {
@@ -3557,21 +4419,57 @@ 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.locusInfo.emit({function: 'test', file: 'test'}, 'LOCUS_INFO_UPDATE_URL', newLocusUrl);
           assert.calledWith(
             meeting.members.locusUrlUpdate,
             newLocusUrl
           );
+          assert.calledOnceWithExactly(meeting.breakouts.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',
+                }
+              },
+          };
+
+          meeting.recordingController = {setServiceUrl: sinon.stub().returns(undefined), setSessionId: sinon.stub().returns(undefined)};
+
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'LINKS_SERVICES',
+            newLocusServices
+          );
+
+          assert.calledWith(meeting.recordingController.setServiceUrl, newLocusServices.services.record.url);
+          assert.calledOnce(meeting.recordingController.setSessionId);
+          done();
+        });
+      });
       describe('#setUpLocusInfoMediaInactiveListener', () => {
         it('listens to disconnect due to un activity ', (done) => {
           TriggerProxy.trigger.reset();
-          meeting.locusInfo.emit({function: 'test', file: 'test'}, EVENTS.DISCONNECT_DUE_TO_INACTIVITY, {reason: 'inactive'});
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            EVENTS.DISCONNECT_DUE_TO_INACTIVITY,
+            {reason: 'inactive'}
+          );
           assert.calledTwice(TriggerProxy.trigger);
 
           assert.calledWith(
@@ -3598,7 +4496,11 @@ describe('plugin-meetings', () => {
           sinon.stub(meeting, 'reconnect');
 
           meeting.config.reconnection.autoRejoin = true;
-          meeting.locusInfo.emit({function: 'test', file: 'test'}, EVENTS.DISCONNECT_DUE_TO_INACTIVITY, {reason: 'inactive'});
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            EVENTS.DISCONNECT_DUE_TO_INACTIVITY,
+            {reason: 'inactive'}
+          );
           assert.calledOnce(TriggerProxy.trigger);
 
           assert.calledWith(
@@ -3623,7 +4525,10 @@ describe('plugin-meetings', () => {
           sinon.stub(meeting.reconnectionManager, 'cleanUp');
           sinon.spy(MeetingUtil, 'cleanUp');
 
-          meeting.locusInfo.emit({function: 'test', file: 'test'}, EVENTS.DESTROY_MEETING, {shouldLeave: false, reason: 'ended'});
+          meeting.locusInfo.emit({function: 'test', file: 'test'}, EVENTS.DESTROY_MEETING, {
+            shouldLeave: false,
+            reason: 'ended',
+          });
           assert.calledOnce(TriggerProxy.trigger);
           assert.calledOnce(MeetingUtil.cleanUp);
           assert.calledWith(
@@ -3631,12 +4536,12 @@ describe('plugin-meetings', () => {
             meeting,
             {
               file: 'meeting/index',
-              function: 'setUpLocusInfoMeetingListener'
+              function: 'setUpLocusInfoMeetingListener',
             },
             EVENTS.DESTROY_MEETING,
             {
               reason: 'ended',
-              meetingId: meeting.id
+              meetingId: meeting.id,
             }
           );
           done();
@@ -3656,22 +4561,36 @@ describe('plugin-meetings', () => {
         sandbox = null;
       });
 
-      describe('#stopFloorRequest', () => {
-        it('should have #stopFloorRequest', () => {
-          assert.exists(meeting.stopFloorRequest);
+      describe('#releaseScreenShareFloor', () => {
+        it('should have #releaseScreenShareFloor', () => {
+          assert.exists(meeting.releaseScreenShareFloor);
         });
         beforeEach(() => {
-          meeting.locusInfo.mediaShares = [{name: 'content', url: url1}];
+          meeting.selfId = 'some self id';
+          meeting.locusInfo.mediaShares = [
+            {name: 'content', url: url1, floor: {beneficiary: {id: meeting.selfId}}},
+          ];
           meeting.locusInfo.self = {url: url2};
+          meeting.mediaProperties = {mediaDirection: {sendShare: true}};
           meeting.meetingRequest.changeMeetingFloor = sinon.stub().returns(Promise.resolve());
         });
-        it('should call change meeting floor', async () => {
-          const share = meeting.share();
+        it('should call changeMeetingFloor()', async () => {
+          const share = meeting.releaseScreenShareFloor();
 
           assert.exists(share.then);
           await share;
           assert.calledOnce(meeting.meetingRequest.changeMeetingFloor);
         });
+        it('should not call changeMeetingFloor() if someone else already has the floor', async () => {
+          // change selfId so that it doesn't match the beneficiary id from meeting.locusInfo.mediaShares
+          meeting.selfId = 'new self id';
+
+          const share = meeting.releaseScreenShareFloor();
+
+          assert.exists(share.then);
+          await share;
+          assert.notCalled(meeting.meetingRequest.changeMeetingFloor);
+        });
       });
 
       describe('#setSipUri', () => {
@@ -3753,8 +4672,8 @@ describe('plugin-meetings', () => {
               permissionToken: 'abc',
               sipMeetingUri: test1,
               sipUrl: test1,
-              owner: test2
-            }
+              owner: test2,
+            },
           };
 
           meeting.parseMeetingInfo(FAKE_MEETING_INFO);
@@ -3765,7 +4684,7 @@ describe('plugin-meetings', () => {
             meetingNumber: '12345',
             meetingJoinUrl: url2,
             owner: test2,
-            permissionToken: 'abc'
+            permissionToken: 'abc',
           };
 
           checkParseMeetingInfo(expectedInfoToParse);
@@ -3779,8 +4698,8 @@ describe('plugin-meetings', () => {
             info: {
               webExMeetingId: 'locusMeetingId',
               sipUri: 'locusSipUri',
-              owner: 'locusOwner'
-            }
+              owner: 'locusOwner',
+            },
           };
           const FAKE_MEETING_INFO = {
             body: {
@@ -3791,8 +4710,8 @@ describe('plugin-meetings', () => {
               permissionToken: 'abc',
               sipMeetingUri: test1,
               sipUrl: test1,
-              owner: test2
-            }
+              owner: test2,
+            },
           };
 
           meeting.parseMeetingInfo(FAKE_MEETING_INFO, FAKE_LOCUS_MEETING);
@@ -3803,7 +4722,7 @@ describe('plugin-meetings', () => {
             meetingNumber: 'locusMeetingId',
             meetingJoinUrl: url2,
             owner: 'locusOwner',
-            permissionToken: 'abc'
+            permissionToken: 'abc',
           };
 
           checkParseMeetingInfo(expectedInfoToParse);
@@ -3820,8 +4739,8 @@ describe('plugin-meetings', () => {
               permissionToken: 'abc',
               sipMeetingUri: test1,
               sipUrl: test1,
-              owner: test2
-            }
+              owner: test2,
+            },
           };
 
           meeting.parseMeetingInfo(FAKE_MEETING_INFO);
@@ -3832,7 +4751,7 @@ describe('plugin-meetings', () => {
             meetingNumber: '12345',
             meetingJoinUrl: url2,
             owner: test2,
-            permissionToken: 'abc'
+            permissionToken: 'abc',
           };
 
           checkParseMeetingInfo(expectedInfoToParse);
@@ -3850,8 +4769,8 @@ describe('plugin-meetings', () => {
               permissionToken: 'abc',
               sipMeetingUri: test1,
               sipUrl: test1,
-              owner: test2
-            }
+              owner: test2,
+            },
           };
 
           meeting.parseMeetingInfo(FAKE_MEETING_INFO, FAKE_STRING_DESTINATION);
@@ -3862,7 +4781,7 @@ describe('plugin-meetings', () => {
             meetingNumber: '12345',
             meetingJoinUrl: url2,
             owner: test2,
-            permissionToken: 'abc'
+            permissionToken: 'abc',
           };
 
           checkParseMeetingInfo(expectedInfoToParse);
@@ -3878,7 +4797,11 @@ describe('plugin-meetings', () => {
             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.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}});
@@ -3927,7 +4850,7 @@ describe('plugin-meetings', () => {
             meeting,
             {
               file: 'meeting/index',
-              function: 'setUpLocusInfoAssignHostListener'
+              function: 'setUpLocusInfoAssignHostListener',
             },
             'meeting:actionsUpdate',
             meeting.inMeetingActions.get()
@@ -3946,30 +4869,47 @@ 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 canEnableReactionsSpy;
+        let canSendReactionsSpy;
 
         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');
-          bothLeaveAndEndMeetingAvailableSpy = sinon.spy(MeetingUtil, 'bothLeaveAndEndMeetingAvailable');
+          bothLeaveAndEndMeetingAvailableSpy = sinon.spy(
+            MeetingUtil,
+            'bothLeaveAndEndMeetingAvailable'
+          );
           canUserLowerSomeoneElsesHandSpy = sinon.spy(MeetingUtil, 'canUserLowerSomeoneElsesHand');
           waitingForOthersToJoinSpy = sinon.spy(MeetingUtil, 'waitingForOthersToJoin');
+          handleDataChannelUrlChangeSpy = sinon.spy(meeting, 'handleDataChannelUrlChange');
+          canEnableReactionsSpy = sinon.spy(MeetingUtil, 'canEnableReactions');
+          canSendReactionsSpy = sinon.spy(MeetingUtil, 'canSendReactions');
         });
 
         afterEach(() => {
@@ -3978,7 +4918,6 @@ describe('plugin-meetings', () => {
           waitingForOthersToJoinSpy.restore();
         });
 
-
         it('registers the correct MEETING_INFO_UPDATED event', () => {
           meeting.setUpLocusInfoMeetingInfoListener();
 
@@ -3991,30 +4930,38 @@ describe('plugin-meetings', () => {
 
           const payload = {
             info: {
-              userDisplayHints: ['LOCK_CONTROL_UNLOCK']
-            }
+              userDisplayHints: ['LOCK_CONTROL_UNLOCK'],
+              datachannelUrl: 'some url',
+            },
           };
 
           callback(payload);
 
           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(canEnableReactionsSpy, null, payload.info.userDisplayHints);
+          assert.calledWith(canSendReactionsSpy, null, payload.info.userDisplayHints);
 
           assert.calledWith(
             TriggerProxy.trigger,
             meeting,
             {
               file: 'meeting/index',
-              function: 'setUpLocusInfoMeetingInfoListener'
+              function: 'setUpLocusInfoMeetingInfoListener',
             },
             'meeting:actionsUpdate',
             meeting.inMeetingActions.get()
@@ -4028,6 +4975,123 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('#handleDataChannelUrlChange', () => {
+        let updateLLMConnectionSpy;
+
+        beforeEach(() => {
+          updateLLMConnectionSpy = sinon.spy(meeting, 'updateLLMConnection');
+        });
+
+        const check = async (url, expectedCalled) => {
+          meeting.handleDataChannelUrlChange(url);
+
+          assert.notCalled(updateLLMConnectionSpy);
+
+          await testUtils.waitUntil(0);
+
+          if (expectedCalled) {
+            assert.calledWith(updateLLMConnectionSpy);
+          } else {
+            assert.notCalled(updateLLMConnectionSpy);
+          }
+        };
+
+        it('calls deferred updateLLMConnection if datachannelURL is set and the enableAutomaticLLM is true', async () => {
+          meeting.config.enableAutomaticLLM = true;
+          check('some url', true);
+        });
+
+        it('does not call updateLLMConnection if datachannelURL is undefined', async () => {
+          meeting.config.enableAutomaticLLM = true;
+          check(undefined, false);
+        });
+
+        it('does not call updateLLMConnection if enableAutomaticLLM is false', async () => {
+          check('some url', false);
+        });
+      });
+
+      describe('#updateLLMConnection', () => {
+        beforeEach(() => {
+          webex.internal.llm.isConnected = sinon.stub().returns(false);
+          webex.internal.llm.getLocusUrl = sinon.stub();
+          webex.internal.llm.registerAndConnect = sinon
+            .stub()
+            .returns(Promise.resolve('something'));
+          webex.internal.llm.disconnectLLM = sinon.stub().returns(Promise.resolve());
+        });
+
+        it('does not connect if the call is not joined yet', async () => {
+          meeting.joinedWith = {state: 'any other state'};
+          webex.internal.llm.getLocusUrl.returns('a url');
+
+          meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
+
+          const result = await meeting.updateLLMConnection();
+
+          assert.notCalled(webex.internal.llm.registerAndConnect);
+          assert.notCalled(webex.internal.llm.disconnectLLM);
+          assert.equal(result, undefined);
+        });
+
+        it('returns undefined if llm is already connected and the locus url is unchanged', async () => {
+          meeting.joinedWith = {state: 'JOINED'};
+          webex.internal.llm.isConnected.returns(true);
+          webex.internal.llm.getLocusUrl.returns('a url');
+
+          meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
+
+          const result = await meeting.updateLLMConnection();
+
+          assert.notCalled(webex.internal.llm.registerAndConnect);
+          assert.notCalled(webex.internal.llm.disconnectLLM);
+          assert.equal(result, undefined);
+        });
+
+        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');
+        });
+
+        it('disconnects if first if the locus url has changed', async () => {
+          meeting.joinedWith = {state: 'JOINED'};
+          webex.internal.llm.isConnected.returns(true);
+          webex.internal.llm.getLocusUrl.returns('a url');
+
+          meeting.locusInfo = {url: 'a different url', info: {datachannelUrl: 'a datachannel url'}};
+
+          const result = await meeting.updateLLMConnection();
+
+          assert.calledWith(webex.internal.llm.disconnectLLM);
+          assert.calledWith(
+            webex.internal.llm.registerAndConnect,
+            'a different url',
+            'a datachannel url'
+          );
+          assert.equal(result, 'something');
+        });
+
+        it('disconnects when the state is not JOINED', async () => {
+          meeting.joinedWith = {state: 'any other state'};
+          webex.internal.llm.isConnected.returns(true);
+          webex.internal.llm.getLocusUrl.returns('a url');
+
+          meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
+
+          const result = await meeting.updateLLMConnection();
+
+          assert.calledWith(webex.internal.llm.disconnectLLM);
+          assert.notCalled(webex.internal.llm.registerAndConnect);
+          assert.equal(result, undefined);
+        });
+      });
+
       describe('#setLocus', () => {
         beforeEach(() => {
           meeting.locusInfo.initialSetup = sinon.stub().returns(true);
@@ -4039,7 +5103,7 @@ describe('plugin-meetings', () => {
             locusId: uuid1,
             selfId: uuid2,
             mediaId: uuid3,
-            host: {id: uuid4}
+            host: {id: uuid4},
           });
           assert.calledOnce(meeting.locusInfo.initialSetup);
           assert.calledWith(meeting.locusInfo.initialSetup, {
@@ -4048,7 +5112,7 @@ describe('plugin-meetings', () => {
             locusId: uuid1,
             selfId: uuid2,
             mediaId: uuid3,
-            host: {id: uuid4}
+            host: {id: uuid4},
           });
           assert.equal(meeting.mediaConnections, test1);
           assert.equal(meeting.locusUrl, url1);
@@ -4097,7 +5161,7 @@ describe('plugin-meetings', () => {
           });
           it('should send the whiteboard share', async () => {
             const whiteboardShare = meeting.startWhiteboardShare({
-              channelUrl: url2
+              channelUrl: url2,
             });
 
             assert.exists(whiteboardShare.then);
@@ -4137,18 +5201,35 @@ describe('plugin-meetings', () => {
           const USER_IDS = {
             ME: '9528d952-e4de-46cf-8157-fd4823b98377',
             REMOTE_A: '5be7e7b0-b304-48da-8083-83bd72b5300d',
-            REMOTE_B: 'd4d102a1-17ce-4e17-9b08-bded3de467e4'
+            REMOTE_B: 'd4d102a1-17ce-4e17-9b08-bded3de467e4',
           };
 
           const RESOURCE_URLS = {
-            WHITEBOARD_A: 'https://board-a.wbx2.com/board/api/v1/channels/49cfb550-5517-11eb-a2af-1b9e4bc3da13',
-            WHITEBOARD_B: 'https://board-a.wbx2.com/board/api/v1/channels/977a7330-54f4-11eb-b1ef-91f5eefc7bf3'
+            WHITEBOARD_A:
+              'https://board-a.wbx2.com/board/api/v1/channels/49cfb550-5517-11eb-a2af-1b9e4bc3da13',
+            WHITEBOARD_B:
+              'https://board-a.wbx2.com/board/api/v1/channels/977a7330-54f4-11eb-b1ef-91f5eefc7bf3',
           };
 
-          const generateContent = (beneficiaryId = null, disposition = null) => ({beneficiaryId, disposition});
-          const generateWhiteboard = (beneficiaryId = null, disposition = null, resourceUrl = null) => ({beneficiaryId, disposition, resourceUrl});
-
-          const generateData = (payload, isGranting, isContent, beneficiaryId, resourceUrl, isAccepting, otherBeneficiaryId) => {
+          const generateContent = (beneficiaryId = null, disposition = null) => ({
+            beneficiaryId,
+            disposition,
+          });
+          const generateWhiteboard = (
+            beneficiaryId = null,
+            disposition = null,
+            resourceUrl = null
+          ) => ({beneficiaryId, disposition, resourceUrl});
+
+          const generateData = (
+            payload,
+            isGranting,
+            isContent,
+            beneficiaryId,
+            resourceUrl,
+            isAccepting,
+            otherBeneficiaryId
+          ) => {
             const newPayload = cloneDeep(payload);
 
             newPayload.previous = cloneDeep(payload.current);
@@ -4159,15 +5240,15 @@ describe('plugin-meetings', () => {
                 eventName: EVENT_TRIGGERS.MEMBERS_CONTENT_UPDATE,
                 eventPayload: {
                   activeSharingId: null,
-                  endedSharingId: null
-                }
-              }
+                  endedSharingId: null,
+                },
+              },
             };
 
             let shareStatus = null;
             const activeSharingId = {
               whiteboard: null,
-              content: null
+              content: null,
             };
 
             if (isGranting) {
@@ -4177,68 +5258,72 @@ describe('plugin-meetings', () => {
 
                 if (isEqual(newPayload.current, newPayload.previous)) {
                   eventTrigger.member = null;
-                }
-                else {
+                } else {
                   if (newPayload.current.whiteboard.beneficiaryId) {
                     if (newPayload.current.whiteboard.disposition === FLOOR_ACTION.GRANTED) {
                       newPayload.current.whiteboard.disposition = FLOOR_ACTION.RELEASED;
                       eventTrigger.share.push({
                         eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_WHITEBOARD,
-                        functionName: 'stopWhiteboardShare'
+                        functionName: 'stopWhiteboardShare',
                       });
-                      eventTrigger.member.eventPayload.endedSharingId = newPayload.current.whiteboard.beneficiaryId;
+                      eventTrigger.member.eventPayload.endedSharingId =
+                        newPayload.current.whiteboard.beneficiaryId;
                     }
                   }
 
                   if (newPayload.previous.content.beneficiaryId) {
-                    if (newPayload.previous.content.beneficiaryId !== newPayload.current.content.beneficiaryId) {
+                    if (
+                      newPayload.previous.content.beneficiaryId !==
+                      newPayload.current.content.beneficiaryId
+                    ) {
                       if (newPayload.previous.content.beneficiaryId === USER_IDS.ME) {
                         eventTrigger.share.push({
                           eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
-                          functionName: 'stopFloorRequest'
+                          functionName: 'localShare',
                         });
-                      }
-                      else if (newPayload.current.content.beneficiaryId === USER_IDS.ME) {
+                      } else if (newPayload.current.content.beneficiaryId === USER_IDS.ME) {
                         eventTrigger.share.push({
                           eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_REMOTE,
-                          functionName: 'remoteShare'
+                          functionName: 'remoteShare',
                         });
                       }
-                      eventTrigger.member.eventPayload.endedSharingId = newPayload.previous.content.beneficiaryId;
+                      eventTrigger.member.eventPayload.endedSharingId =
+                        newPayload.previous.content.beneficiaryId;
                     }
                   }
 
                   if (isAccepting) {
                     eventTrigger.share.push({
                       eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_WHITEBOARD,
-                      functionName: 'stopWhiteboardShare'
+                      functionName: 'stopWhiteboardShare',
                     });
                   }
 
                   if (beneficiaryId === USER_IDS.ME) {
                     eventTrigger.share.push({
                       eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_LOCAL,
-                      functionName: 'share'
+                      functionName: 'share',
                     });
-                  }
-                  else {
+                  } else {
                     eventTrigger.share.push({
                       eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_REMOTE,
                       functionName: 'remoteShare',
-                      eventPayload: {memberId: beneficiaryId}
+                      eventPayload: {memberId: beneficiaryId},
                     });
                   }
                 }
 
                 if (beneficiaryId === USER_IDS.ME) {
                   shareStatus = SHARE_STATUS.LOCAL_SHARE_ACTIVE;
-                }
-                else {
+                } else {
                   shareStatus = SHARE_STATUS.REMOTE_SHARE_ACTIVE;
                 }
-              }
-              else {
-                newPayload.current.whiteboard = generateWhiteboard(beneficiaryId, FLOOR_ACTION.GRANTED, resourceUrl);
+              } else {
+                newPayload.current.whiteboard = generateWhiteboard(
+                  beneficiaryId,
+                  FLOOR_ACTION.GRANTED,
+                  resourceUrl
+                );
 
                 if (newPayload.current.content.beneficiaryId) {
                   if (newPayload.current.content.disposition === FLOOR_ACTION.GRANTED) {
@@ -4246,41 +5331,48 @@ describe('plugin-meetings', () => {
                     if (newPayload.current.content.beneficiaryId === USER_IDS.ME) {
                       eventTrigger.share.push({
                         eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
-                        functionName: 'stopFloorRequest'
+                        functionName: 'localShare',
                       });
-                    }
-                    else {
+                    } else {
                       eventTrigger.share.push({
                         eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_REMOTE,
-                        functionName: 'remoteShare'
+                        functionName: 'remoteShare',
                       });
                     }
 
-                    eventTrigger.member.eventPayload.endedSharingId = newPayload.current.content.beneficiaryId;
+                    eventTrigger.member.eventPayload.endedSharingId =
+                      newPayload.current.content.beneficiaryId;
                   }
                 }
 
                 if (newPayload.previous.content.beneficiaryId) {
-                  if (newPayload.previous.content.beneficiaryId !== newPayload.current.content.beneficiaryId) {
+                  if (
+                    newPayload.previous.content.beneficiaryId !==
+                    newPayload.current.content.beneficiaryId
+                  ) {
                     if (newPayload.previous.content.beneficiaryId === USER_IDS.ME) {
                       eventTrigger.share.push({
                         eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
-                        functionName: 'stopFloorRequest'
+                        functionName: 'localShare',
                       });
-                    }
-                    else if (newPayload.current.content.beneficiaryId === USER_IDS.ME) {
+                    } else if (newPayload.current.content.beneficiaryId === USER_IDS.ME) {
                       eventTrigger.share.push({
                         eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_REMOTE,
-                        functionName: 'remoteShare'
+                        functionName: 'remoteShare',
                       });
                     }
-                    eventTrigger.member.eventPayload.endedSharingId = newPayload.previous.content.beneficiaryId;
+                    eventTrigger.member.eventPayload.endedSharingId =
+                      newPayload.previous.content.beneficiaryId;
                   }
                 }
 
                 if (newPayload.previous.whiteboard.beneficiaryId) {
-                  if (newPayload.previous.whiteboard.beneficiaryId !== newPayload.current.whiteboard.beneficiaryId) {
-                    eventTrigger.member.eventPayload.endedSharingId = newPayload.previous.whiteboard.beneficiaryId;
+                  if (
+                    newPayload.previous.whiteboard.beneficiaryId !==
+                    newPayload.current.whiteboard.beneficiaryId
+                  ) {
+                    eventTrigger.member.eventPayload.endedSharingId =
+                      newPayload.previous.whiteboard.beneficiaryId;
                   }
                 }
 
@@ -4289,7 +5381,7 @@ describe('plugin-meetings', () => {
                 eventTrigger.share.push({
                   eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_WHITEBOARD,
                   functionName: 'startWhiteboardShare',
-                  eventPayload: {resourceUrl, memberId: beneficiaryId}
+                  eventPayload: {resourceUrl, memberId: beneficiaryId},
                 });
 
                 shareStatus = SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE;
@@ -4298,8 +5390,7 @@ describe('plugin-meetings', () => {
               if (eventTrigger.member) {
                 eventTrigger.member.eventPayload.activeSharingId = beneficiaryId;
               }
-            }
-            else {
+            } else {
               eventTrigger.member.eventPayload.endedSharingId = beneficiaryId;
 
               if (isContent) {
@@ -4308,19 +5399,17 @@ describe('plugin-meetings', () => {
                 if (beneficiaryId === USER_IDS.ME) {
                   eventTrigger.share.push({
                     eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
-                    functionName: 'stopFloorRequest'
+                    functionName: 'localShare',
                   });
-                }
-                else {
+                } else {
                   eventTrigger.share.push({
                     eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_REMOTE,
-                    functionName: 'remoteShare'
+                    functionName: 'remoteShare',
                   });
                 }
 
                 shareStatus = SHARE_STATUS.NO_SHARE;
-              }
-              else {
+              } else {
                 newPayload.current.whiteboard.disposition = FLOOR_ACTION.RELEASED;
 
                 if (isAccepting) {
@@ -4330,15 +5419,14 @@ describe('plugin-meetings', () => {
                   eventTrigger.share.push({
                     eventName: EVENT_TRIGGERS.MEETING_STARTED_SHARING_WHITEBOARD,
                     functionName: 'startWhiteboardShare',
-                    eventPayload: {resourceUrl, memberId: beneficiaryId}
+                    eventPayload: {resourceUrl, memberId: beneficiaryId},
                   });
 
                   shareStatus = SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE;
-                }
-                else {
+                } else {
                   eventTrigger.share.push({
                     eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_WHITEBOARD,
-                    functionName: 'stopWhiteboardShare'
+                    functionName: 'stopWhiteboardShare',
                   });
 
                   shareStatus = SHARE_STATUS.NO_SHARE;
@@ -4347,22 +5435,24 @@ describe('plugin-meetings', () => {
             }
 
             return {
-              payload: newPayload, eventTrigger, shareStatus, activeSharingId
+              payload: newPayload,
+              eventTrigger,
+              shareStatus,
+              activeSharingId,
             };
           };
 
           const blankPayload = {
             previous: {
               content: generateContent(),
-              whiteboard: generateWhiteboard()
+              whiteboard: generateWhiteboard(),
             },
             current: {
               content: generateContent(),
-              whiteboard: generateWhiteboard()
-            }
+              whiteboard: generateWhiteboard(),
+            },
           };
 
-
           const payloadTestHelper = (data) => {
             assert.equal(meeting.shareStatus, SHARE_STATUS.NO_SHARE);
 
@@ -4370,23 +5460,33 @@ describe('plugin-meetings', () => {
             let callCounter = 1;
 
             data.forEach((d, index) => {
-              meeting.locusInfo.emit({function: 'test', file: 'test'}, EVENTS.LOCUS_INFO_UPDATE_MEDIA_SHARES, d.payload);
+              meeting.locusInfo.emit(
+                {function: 'test', file: 'test'},
+                EVENTS.LOCUS_INFO_UPDATE_MEDIA_SHARES,
+                d.payload
+              );
 
               assert.equal(meeting.shareStatus, data[index].shareStatus);
 
-              callCounter += data[index].eventTrigger.share.length + (data[index].eventTrigger.member ? 1 : 0);
+              callCounter +=
+                data[index].eventTrigger.share.length + (data[index].eventTrigger.member ? 1 : 0);
 
               assert.callCount(TriggerProxy.trigger, callCounter);
 
-              assert.equal(meeting.members.mediaShareWhiteboardId, data[index].activeSharingId.whiteboard);
-              assert.equal(meeting.members.mediaShareContentId, data[index].activeSharingId.content);
+              assert.equal(
+                meeting.members.mediaShareWhiteboardId,
+                data[index].activeSharingId.whiteboard
+              );
+              assert.equal(
+                meeting.members.mediaShareContentId,
+                data[index].activeSharingId.content
+              );
             });
 
             assert.callCount(TriggerProxy.trigger, callCounter);
 
             // Start with 1 to ignore members:update trigger
 
-
             let i = 1;
             let offset = 2;
 
@@ -4398,21 +5498,24 @@ describe('plugin-meetings', () => {
               for (let idx = 0; idx < share.length; idx += 1) {
                 const shareCallArgs = TriggerProxy.trigger.getCall(i + idx).args;
                 const {functionName, eventName, eventPayload} = share[idx];
-                const fileName = functionName === 'remoteShare' ? 'meetings/index' : 'meeting/index';
+                const fileName =
+                  functionName === 'remoteShare' ? 'meetings/index' : 'meeting/index';
 
                 assert.deepEqual(shareCallArgs[1], {
                   file: fileName,
-                  function: functionName
+                  function: functionName,
                 });
 
-
                 assert.equal(shareCallArgs[2], eventName);
 
                 if (functionName === 'startWhiteboardShare') {
                   assert.deepEqual(shareCallArgs[3], eventPayload);
                 }
 
-                if (functionName === 'remoteShare' && eventName === EVENT_TRIGGERS.MEETING_STARTED_SHARING_REMOTE) {
+                if (
+                  functionName === 'remoteShare' &&
+                  eventName === EVENT_TRIGGERS.MEETING_STARTED_SHARING_REMOTE
+                ) {
                   assert.deepEqual(shareCallArgs[3], eventPayload);
                 }
               }
@@ -4423,7 +5526,7 @@ describe('plugin-meetings', () => {
 
                 assert.deepEqual(memberCallArgs[1], {
                   file: 'members',
-                  function: 'locusMediaSharesUpdate'
+                  function: 'locusMediaSharesUpdate',
                 });
                 assert.equal(memberCallArgs[2], member.eventName);
 
@@ -4437,9 +5540,8 @@ describe('plugin-meetings', () => {
 
               if (share.length + 1 > offset) {
                 offset = (offset + share.length + 1) / 2;
-              }
-              else if (share.length + 1 < offset) {
-                offset = (share.length + 1) + 0.5;
+              } else if (share.length + 1 < offset) {
+                offset = share.length + 1 + 0.5;
               }
             }
           };
@@ -4450,40 +5552,100 @@ describe('plugin-meetings', () => {
 
           describe('Whiteboard A --> Whiteboard B', () => {
             it('Scenario #1: you share both whiteboards', () => {
-              const data1 = generateData(blankPayload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A);
-              const data2 = generateData(data1.payload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_B);
+              const data1 = generateData(
+                blankPayload,
+                true,
+                false,
+                USER_IDS.ME,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
+              const data2 = generateData(
+                data1.payload,
+                true,
+                false,
+                USER_IDS.ME,
+                RESOURCE_URLS.WHITEBOARD_B
+              );
               const data3 = generateData(data2.payload, false, false, USER_IDS.ME);
 
               payloadTestHelper([data1, data2, data3]);
             });
 
             it('Scenario #2: you share whiteboard A and remote person A shares whiteboard B', () => {
-              const data1 = generateData(blankPayload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A);
-              const data2 = generateData(data1.payload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_B);
+              const data1 = generateData(
+                blankPayload,
+                true,
+                false,
+                USER_IDS.ME,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
+              const data2 = generateData(
+                data1.payload,
+                true,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_B
+              );
               const data3 = generateData(data2.payload, false, false, USER_IDS.REMOTE_A);
 
               payloadTestHelper([data1, data2, data3]);
             });
 
             it('Scenario #3: remote person A shares whiteboard A and you share whiteboard B', () => {
-              const data1 = generateData(blankPayload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
-              const data2 = generateData(data1.payload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_B);
+              const data1 = generateData(
+                blankPayload,
+                true,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
+              const data2 = generateData(
+                data1.payload,
+                true,
+                false,
+                USER_IDS.ME,
+                RESOURCE_URLS.WHITEBOARD_B
+              );
               const data3 = generateData(data2.payload, false, false, USER_IDS.ME);
 
               payloadTestHelper([data1, data2, data3]);
             });
 
             it('Scenario #4: remote person A shares both whiteboards', () => {
-              const data1 = generateData(blankPayload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
-              const data2 = generateData(data1.payload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_B);
+              const data1 = generateData(
+                blankPayload,
+                true,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
+              const data2 = generateData(
+                data1.payload,
+                true,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_B
+              );
               const data3 = generateData(data2.payload, false, false, USER_IDS.REMOTE_A);
 
               payloadTestHelper([data1, data2, data3]);
             });
 
             it('Scenario #5: remote person A shares whiteboard A and remote person B shares whiteboard B', () => {
-              const data1 = generateData(blankPayload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
-              const data2 = generateData(data1.payload, true, false, USER_IDS.REMOTE_B, RESOURCE_URLS.WHITEBOARD_B);
+              const data1 = generateData(
+                blankPayload,
+                true,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
+              const data2 = generateData(
+                data1.payload,
+                true,
+                false,
+                USER_IDS.REMOTE_B,
+                RESOURCE_URLS.WHITEBOARD_B
+              );
               const data3 = generateData(data2.payload, false, false, USER_IDS.REMOTE_B);
 
               payloadTestHelper([data1, data2, data3]);
@@ -4492,45 +5654,155 @@ describe('plugin-meetings', () => {
 
           describe('Whiteboard A --> Desktop', () => {
             it('Scenario #1: you share whiteboard and then share desktop', () => {
-              const data1 = generateData(blankPayload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A);
-              const data2 = generateData(data1.payload, false, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A, true, USER_IDS.ME);
-              const data3 = generateData(data2.payload, true, true, USER_IDS.ME, undefined, true, USER_IDS.ME);
+              const data1 = generateData(
+                blankPayload,
+                true,
+                false,
+                USER_IDS.ME,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
+              const data2 = generateData(
+                data1.payload,
+                false,
+                false,
+                USER_IDS.ME,
+                RESOURCE_URLS.WHITEBOARD_A,
+                true,
+                USER_IDS.ME
+              );
+              const data3 = generateData(
+                data2.payload,
+                true,
+                true,
+                USER_IDS.ME,
+                undefined,
+                true,
+                USER_IDS.ME
+              );
               const data4 = generateData(data3.payload, false, true, USER_IDS.ME);
 
               payloadTestHelper([data1, data2, data3, data4]);
             });
 
             it('Scenario #2: you share whiteboard A and remote person A shares desktop', () => {
-              const data1 = generateData(blankPayload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A);
-              const data2 = generateData(data1.payload, false, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A, true, USER_IDS.REMOTE_A);
-              const data3 = generateData(data2.payload, true, true, USER_IDS.REMOTE_A, undefined, true, USER_IDS.ME);
+              const data1 = generateData(
+                blankPayload,
+                true,
+                false,
+                USER_IDS.ME,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
+              const data2 = generateData(
+                data1.payload,
+                false,
+                false,
+                USER_IDS.ME,
+                RESOURCE_URLS.WHITEBOARD_A,
+                true,
+                USER_IDS.REMOTE_A
+              );
+              const data3 = generateData(
+                data2.payload,
+                true,
+                true,
+                USER_IDS.REMOTE_A,
+                undefined,
+                true,
+                USER_IDS.ME
+              );
               const data4 = generateData(data3.payload, false, true, USER_IDS.REMOTE_A);
 
               payloadTestHelper([data1, data2, data3, data4]);
             });
 
             it('Scenario #3: remote person A shares whiteboard and you share desktop', () => {
-              const data1 = generateData(blankPayload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
-              const data2 = generateData(data1.payload, false, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A, true, USER_IDS.ME);
-              const data3 = generateData(data2.payload, true, true, USER_IDS.ME, undefined, true, USER_IDS.REMOTE_A);
+              const data1 = generateData(
+                blankPayload,
+                true,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
+              const data2 = generateData(
+                data1.payload,
+                false,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_A,
+                true,
+                USER_IDS.ME
+              );
+              const data3 = generateData(
+                data2.payload,
+                true,
+                true,
+                USER_IDS.ME,
+                undefined,
+                true,
+                USER_IDS.REMOTE_A
+              );
               const data4 = generateData(data3.payload, false, true, USER_IDS.ME);
 
               payloadTestHelper([data1, data2, data3, data4]);
             });
 
             it('Scenario #4: remote person A shares whiteboard and then shares desktop', () => {
-              const data1 = generateData(blankPayload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
-              const data2 = generateData(data1.payload, false, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A, true, USER_IDS.REMOTE_A);
-              const data3 = generateData(data2.payload, true, true, USER_IDS.REMOTE_A, undefined, true, USER_IDS.REMOTE_A);
+              const data1 = generateData(
+                blankPayload,
+                true,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
+              const data2 = generateData(
+                data1.payload,
+                false,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_A,
+                true,
+                USER_IDS.REMOTE_A
+              );
+              const data3 = generateData(
+                data2.payload,
+                true,
+                true,
+                USER_IDS.REMOTE_A,
+                undefined,
+                true,
+                USER_IDS.REMOTE_A
+              );
               const data4 = generateData(data3.payload, false, true, USER_IDS.REMOTE_A);
 
               payloadTestHelper([data1, data2, data3, data4]);
             });
 
             it('Scenario #5: remote person A shares whiteboard and remote person B shares desktop', () => {
-              const data1 = generateData(blankPayload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
-              const data2 = generateData(data1.payload, false, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A, true, USER_IDS.REMOTE_B);
-              const data3 = generateData(data2.payload, true, true, USER_IDS.REMOTE_B, undefined, true, USER_IDS.REMOTE_A);
+              const data1 = generateData(
+                blankPayload,
+                true,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
+              const data2 = generateData(
+                data1.payload,
+                false,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_A,
+                true,
+                USER_IDS.REMOTE_B
+              );
+              const data3 = generateData(
+                data2.payload,
+                true,
+                true,
+                USER_IDS.REMOTE_B,
+                undefined,
+                true,
+                USER_IDS.REMOTE_A
+              );
               const data4 = generateData(data3.payload, false, true, USER_IDS.REMOTE_B);
 
               payloadTestHelper([data1, data2, data3, data4]);
@@ -4540,7 +5812,13 @@ describe('plugin-meetings', () => {
           describe('Desktop --> Whiteboard A', () => {
             it('Scenario #1: you share desktop and then share whiteboard', () => {
               const data1 = generateData(blankPayload, true, true, USER_IDS.ME);
-              const data2 = generateData(data1.payload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(
+                data1.payload,
+                true,
+                false,
+                USER_IDS.ME,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
               const data3 = generateData(data2.payload, false, false, USER_IDS.ME);
 
               payloadTestHelper([data1, data2, data3]);
@@ -4548,7 +5826,13 @@ describe('plugin-meetings', () => {
 
             it('Scenario #2: you share desktop and remote person A shares whiteboard', () => {
               const data1 = generateData(blankPayload, true, true, USER_IDS.ME);
-              const data2 = generateData(data1.payload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(
+                data1.payload,
+                true,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
               const data3 = generateData(data2.payload, false, false, USER_IDS.REMOTE_A);
 
               payloadTestHelper([data1, data2, data3]);
@@ -4556,7 +5840,13 @@ describe('plugin-meetings', () => {
 
             it('Scenario #3: remote person A shares desktop and you share whiteboard', () => {
               const data1 = generateData(blankPayload, true, true, USER_IDS.REMOTE_A);
-              const data2 = generateData(data1.payload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(
+                data1.payload,
+                true,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
               const data3 = generateData(data2.payload, false, false, USER_IDS.REMOTE_A);
 
               payloadTestHelper([data1, data2, data3]);
@@ -4564,7 +5854,13 @@ describe('plugin-meetings', () => {
 
             it('Scenario #4: remote person A shares desktop and then shares whiteboard', () => {
               const data1 = generateData(blankPayload, true, true, USER_IDS.REMOTE_A);
-              const data2 = generateData(data1.payload, true, false, USER_IDS.ME, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(
+                data1.payload,
+                true,
+                false,
+                USER_IDS.ME,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
               const data3 = generateData(data2.payload, false, false, USER_IDS.ME);
 
               payloadTestHelper([data1, data2, data3]);
@@ -4572,7 +5868,13 @@ describe('plugin-meetings', () => {
 
             it('Scenario #5: remote person A shares desktop and remote person B shares whiteboard', () => {
               const data1 = generateData(blankPayload, true, true, USER_IDS.REMOTE_A);
-              const data2 = generateData(data1.payload, true, false, USER_IDS.REMOTE_A, RESOURCE_URLS.WHITEBOARD_A);
+              const data2 = generateData(
+                data1.payload,
+                true,
+                false,
+                USER_IDS.REMOTE_A,
+                RESOURCE_URLS.WHITEBOARD_A
+              );
               const data3 = generateData(data2.payload, false, false, USER_IDS.REMOTE_A);
 
               payloadTestHelper([data1, data2, data3]);
@@ -4648,17 +5950,21 @@ describe('plugin-meetings', () => {
           assert.isNull(meeting.keepAliveTimerId);
           meeting.joinedWith = {
             keepAliveUrl: defaultKeepAliveUrl,
-            keepAliveSecs: defaultKeepAliveSecs
+            keepAliveSecs: defaultKeepAliveSecs,
           };
           meeting.startKeepAlive();
           assert.isNumber(meeting.keepAliveTimerId.id);
           await testUtils.flushPromises();
           assert.notCalled(meeting.meetingRequest.keepAlive);
           await progressTime(defaultExpectedInterval);
-          assert.calledOnceWithExactly(meeting.meetingRequest.keepAlive, {keepAliveUrl: defaultKeepAliveUrl});
+          assert.calledOnceWithExactly(meeting.meetingRequest.keepAlive, {
+            keepAliveUrl: defaultKeepAliveUrl,
+          });
           await progressTime(defaultExpectedInterval);
           assert.calledTwice(meeting.meetingRequest.keepAlive);
-          assert.alwaysCalledWithExactly(meeting.meetingRequest.keepAlive, {keepAliveUrl: defaultKeepAliveUrl});
+          assert.alwaysCalledWithExactly(meeting.meetingRequest.keepAlive, {
+            keepAliveUrl: defaultKeepAliveUrl,
+          });
         });
         it('startKeepAlive handles existing keepAliveTimerId', async () => {
           meeting.meetingRequest.keepAlive = sinon.stub().returns(Promise.resolve());
@@ -4667,7 +5973,7 @@ describe('plugin-meetings', () => {
           meeting.keepAliveTimerId = 7;
           meeting.joinedWith = {
             keepAliveUrl: defaultKeepAliveUrl,
-            keepAliveSecs: defaultKeepAliveSecs
+            keepAliveSecs: defaultKeepAliveSecs,
           };
           meeting.startKeepAlive();
           assert.equal(meeting.keepAliveTimerId, 7);
@@ -4680,7 +5986,7 @@ describe('plugin-meetings', () => {
 
           assert.isNull(meeting.keepAliveTimerId);
           meeting.joinedWith = {
-            keepAliveSecs: defaultKeepAliveSecs
+            keepAliveSecs: defaultKeepAliveSecs,
           };
           meeting.startKeepAlive();
           assert.isNull(meeting.keepAliveTimerId);
@@ -4693,7 +5999,7 @@ describe('plugin-meetings', () => {
 
           assert.isNull(meeting.keepAliveTimerId);
           meeting.joinedWith = {
-            keepAliveUrl: defaultKeepAliveUrl
+            keepAliveUrl: defaultKeepAliveUrl,
           };
           meeting.startKeepAlive();
           assert.isNull(meeting.keepAliveTimerId);
@@ -4707,7 +6013,7 @@ describe('plugin-meetings', () => {
           assert.isNull(meeting.keepAliveTimerId);
           meeting.joinedWith = {
             keepAliveUrl: defaultKeepAliveUrl,
-            keepAliveSecs: 1
+            keepAliveSecs: 1,
           };
           meeting.startKeepAlive();
           assert.isNull(meeting.keepAliveTimerId);
@@ -4720,14 +6026,16 @@ describe('plugin-meetings', () => {
           assert.isNull(meeting.keepAliveTimerId);
           meeting.joinedWith = {
             keepAliveUrl: defaultKeepAliveUrl,
-            keepAliveSecs: defaultKeepAliveSecs
+            keepAliveSecs: defaultKeepAliveSecs,
           };
           meeting.startKeepAlive();
           assert.isNumber(meeting.keepAliveTimerId.id);
           await testUtils.flushPromises();
           assert.notCalled(meeting.meetingRequest.keepAlive);
           await progressTime(defaultExpectedInterval);
-          assert.calledOnceWithExactly(meeting.meetingRequest.keepAlive, {keepAliveUrl: defaultKeepAliveUrl});
+          assert.calledOnceWithExactly(meeting.meetingRequest.keepAlive, {
+            keepAliveUrl: defaultKeepAliveUrl,
+          });
           assert.isNull(meeting.keepAliveTimerId);
           await progressTime(defaultExpectedInterval);
           assert.calledOnce(meeting.meetingRequest.keepAlive);
@@ -4757,12 +6065,14 @@ describe('plugin-meetings', () => {
           assert.isNull(meeting.keepAliveTimerId);
           meeting.joinedWith = {
             keepAliveUrl: defaultKeepAliveUrl,
-            keepAliveSecs: defaultKeepAliveSecs
+            keepAliveSecs: defaultKeepAliveSecs,
           };
           meeting.startKeepAlive();
           assert.isNumber(meeting.keepAliveTimerId.id);
           await progressTime(defaultExpectedInterval);
-          assert.calledOnceWithExactly(meeting.meetingRequest.keepAlive, {keepAliveUrl: defaultKeepAliveUrl});
+          assert.calledOnceWithExactly(meeting.meetingRequest.keepAlive, {
+            keepAliveUrl: defaultKeepAliveUrl,
+          });
 
           meeting.stopKeepAlive();
           assert.isNull(meeting.keepAliveTimerId);
@@ -4774,6 +6084,164 @@ describe('plugin-meetings', () => {
           meeting.stopKeepAlive();
         });
       });
+
+      describe('#sendReaction', () => {
+        it('should have #sendReaction', () => {
+          assert.exists(meeting.sendReaction);
+        });
+
+        beforeEach(() => {
+          meeting.meetingRequest.sendReaction = sinon.stub().returns(Promise.resolve());
+        });
+
+        it('should send reaction with the right data and return a promise', async () => {
+          meeting.locusInfo.controls = {reactions: {reactionChannelUrl: 'Fake URL'}};
+
+          const reactionPromise = meeting.sendReaction('thumb_down', 'light');
+
+          assert.exists(reactionPromise.then);
+          await reactionPromise;
+          assert.calledOnceWithExactly(meeting.meetingRequest.sendReaction, {
+            reactionChannelUrl: 'Fake URL',
+            reaction: {
+              type: 'thumb_down',
+              codepoints: '1F44E',
+              shortcodes: ':thumbsdown:',
+              tone: {
+                type: 'light_skin_tone',
+                codepoints: '1F3FB',
+                shortcodes: ':skin-tone-2:',
+              },
+            },
+            participantId: meeting.members.selfId,
+          });
+        });
+
+        it('should fail sending a reaction if data channel is undefined', async () => {
+          meeting.locusInfo.controls = {reactions: {reactionChannelUrl: undefined}};
+
+          await assert.isRejected(
+            meeting.sendReaction('thumb_down', 'light'),
+            Error,
+            'Error sending reaction, service url not found.'
+          );
+
+          assert.notCalled(meeting.meetingRequest.sendReaction);
+        });
+
+        it('should fail sending a reaction if reactionType is invalid ', async () => {
+          meeting.locusInfo.controls = {reactions: {reactionChannelUrl: 'Fake URL'}};
+
+          await assert.isRejected(
+            meeting.sendReaction('invalid_reaction', 'light'),
+            Error,
+            'invalid_reaction is not a valid reaction.'
+          );
+
+          assert.notCalled(meeting.meetingRequest.sendReaction);
+        });
+
+        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('thumb_down', 'invalid_skin_tone');
+
+          assert.exists(reactionPromise.then);
+          await reactionPromise;
+          assert.calledOnceWithExactly(meeting.meetingRequest.sendReaction, {
+            reactionChannelUrl: 'Fake URL',
+            reaction: {
+              type: 'thumb_down',
+              codepoints: '1F44E',
+              shortcodes: ':thumbsdown:',
+              tone: {type: 'normal_skin_tone', codepoints: '', shortcodes: ''},
+            },
+            participantId: meeting.members.selfId,
+          });
+        });
+
+        it('should send a reaction with default skin tone if none provided', async () => {
+          meeting.locusInfo.controls = {reactions: {reactionChannelUrl: 'Fake URL'}};
+
+          const reactionPromise = meeting.sendReaction('thumb_down');
+
+          assert.exists(reactionPromise.then);
+          await reactionPromise;
+          assert.calledOnceWithExactly(meeting.meetingRequest.sendReaction, {
+            reactionChannelUrl: 'Fake URL',
+            reaction: {
+              type: 'thumb_down',
+              codepoints: '1F44E',
+              shortcodes: ':thumbsdown:',
+              tone: {type: 'normal_skin_tone', codepoints: '', shortcodes: ''},
+            },
+            participantId: meeting.members.selfId,
+          });
+        });
+      });
+      describe('#toggleReactions', () => {
+        it('should have #toggleReactions', () => {
+          assert.exists(meeting.toggleReactions);
+        });
+
+        beforeEach(() => {
+          meeting.meetingRequest.toggleReactions = sinon.stub().returns(Promise.resolve());
+        });
+
+        it('should toggle the reactions with the right data and return a promise', async () => {
+          meeting.locusUrl = 'locusUrl';
+          meeting.locusInfo.controls = {reactions: {enabled: false}};
+
+          const togglePromise = meeting.toggleReactions(true);
+
+          assert.exists(togglePromise.then);
+          await togglePromise;
+          assert.calledOnceWithExactly(meeting.meetingRequest.toggleReactions, {
+            locusUrl: 'locusUrl',
+            enable: true,
+            requestingParticipantId: meeting.members.selfId,
+          });
+        });
+
+        it('should resolve immediately if already enabled', async () => {
+          meeting.locusUrl = 'locusUrl';
+          meeting.locusInfo.controls = {reactions: {enabled: true}};
+
+          const togglePromise = meeting.toggleReactions(true);
+
+          const response = await togglePromise;
+
+          assert.equal(response, 'Reactions are already enabled.');
+          assert.notCalled(meeting.meetingRequest.toggleReactions);
+        });
+
+        it('should resolve immediately if already disabled', async () => {
+          meeting.locusUrl = 'locusUrl';
+          meeting.locusInfo.controls = {reactions: {enabled: false}};
+
+          const togglePromise = meeting.toggleReactions(false);
+
+          const response = await togglePromise;
+
+          assert.equal(response, 'Reactions are already disabled.');
+          assert.notCalled(meeting.meetingRequest.toggleReactions);
+        });
+
+        it('should toggle reactions on if controls is undefined and enable = true', async () => {
+          meeting.locusUrl = 'locusUrl';
+          meeting.locusInfo.controls = undefined;
+
+          const togglePromise = meeting.toggleReactions(true);
+
+          assert.exists(togglePromise.then);
+          await togglePromise;
+          assert.calledOnceWithExactly(meeting.meetingRequest.toggleReactions, {
+            locusUrl: 'locusUrl',
+            enable: true,
+            requestingParticipantId: meeting.members.selfId,
+          });
+        });
+      });
     });
   });
 });