@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.11

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

@@ -20,7 +20,9 @@ import {
   _SIP_URI_,
   _MEETING_ID_,
   LOCUSINFO,
+  PC_BAIL_TIMEOUT,
 } from '@webex/plugin-meetings/src/constants';
+import {MediaConnection as MC} from '@webex/internal-media-core';
 import * as StatsAnalyzerModule from '@webex/plugin-meetings/src/statsAnalyzer';
 import EventsScope from '@webex/plugin-meetings/src/common/events/events-scope';
 import Meetings, {CONSTANTS} from '@webex/plugin-meetings';
@@ -32,7 +34,6 @@ import LocusInfo from '@webex/plugin-meetings/src/locus-info';
 import MediaProperties from '@webex/plugin-meetings/src/media/properties';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import Media from '@webex/plugin-meetings/src/media/index';
-import PeerConnectionManager from '@webex/plugin-meetings/src/peer-connection-manager';
 import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
 import MediaUtil from '@webex/plugin-meetings/src/media/util';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
@@ -178,7 +179,6 @@ describe('plugin-meetings', () => {
     TriggerProxy.trigger = sinon.stub().returns(true);
     Metrics.postEvent = sinon.stub();
     Metrics.initialSetup(null, webex);
-    MediaUtil.createPeerConnection = sinon.stub().returns({});
     MediaUtil.createMediaStream = sinon.stub().returns(true);
 
     uuid1 = uuid.v4();
@@ -222,7 +222,6 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.userId, uuid1);
           assert.equal(meeting.resource, uuid2);
           assert.equal(meeting.deviceUrl, uuid3);
-          assert.equal(meeting.roapSeq, -1);
           assert.deepEqual(meeting.meetingInfo, {});
           assert.instanceOf(meeting.members, Members);
           assert.instanceOf(meeting.roap, Roap);
@@ -783,6 +782,7 @@ describe('plugin-meetings', () => {
       });
       describe('#join', () => {
         let sandbox = null;
+        const joinMeetingResult = 'JOIN_MEETINGS_OPTION_RESULT';
 
         beforeEach(() => {
           sandbox = sinon.createSandbox();
@@ -800,10 +800,11 @@ 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 () => {
@@ -812,10 +813,26 @@ describe('plugin-meetings', () => {
             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;
+            await meeting.join();
+
+            assert.calledOnce(meeting.updateLLMConnection);
           });
+
+          it('should not call updateLLMConnection upon joining if config value is not set', async () => {
+            await meeting.join();
+
+            assert.notCalled(meeting.updateLLMConnection);
+          });
+
           it('should invoke `receiveTranscription()` if receiveTranscription is set to true', async () => {
             meeting.isTranscriptionSupported = sinon.stub().returns(true);
             meeting.receiveTranscription = sinon.stub().returns(Promise.resolve());
@@ -909,22 +926,25 @@ describe('plugin-meetings', () => {
           applyClientStateLocally: sinon.stub().returns(Promise.resolve(true))
         };
 
+        let fakeMediaConnection;
+
         beforeEach(() => {
+          fakeMediaConnection = {
+            close: sinon.stub(),
+            getConnectionState: sinon.stub().returns(MC.ConnectionState.Connected),
+            initiateOffer: sinon.stub().resolves({}),
+            on: sinon.stub(),
+          };
           meeting.mediaProperties.setMediaDirection = sinon.stub().returns(true);
-          meeting.mediaProperties.waitForIceConnectedState = sinon.stub().resolves();
+          meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
           meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
           meeting.audio = muteStateStub;
           meeting.video = muteStateStub;
-          Media.attachMedia = sinon.stub().returns(Promise.resolve([test1, test2]));
+          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
           meeting.setMercuryListener = sinon.stub().returns(true);
-          meeting.setRemoteStream = sinon.stub().returns(true);
+          meeting.setupMediaConnectionListeners = sinon.stub();
           meeting.setMercuryListener = sinon.stub();
-          meeting.roap.sendRoapMediaRequest = sinon.stub().returns(new Promise((resolve) => {
-            meeting.mediaProperties.peerConnection.connectionState = CONSTANTS.CONNECTION_STATE.CONNECTED;
-            resolve();
-          }));
           meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: {}, turnDiscoverySkippedReason: undefined});
-          PeerConnectionManager.setContentSlides = sinon.stub().returns(true);
         });
 
         it('should have #addMedia', () => {
@@ -932,16 +952,17 @@ describe('plugin-meetings', () => {
         });
 
         it('should reject promise if meeting is not active', async () => {
-          await meeting.addMedia().catch((err) => {
-            assert.instanceOf(err, MeetingNotActiveError);
-          });
+          const result = await assert.isRejected(meeting.addMedia());
+
+          assert.instanceOf(result, MeetingNotActiveError);
         });
 
         it('should reject promise if user already in left state', async () => {
           meeting.meetingState = 'ACTIVE';
-          await meeting.addMedia().catch((err) => {
-            assert.instanceOf(err, UserNotJoinedError);
-          });
+          meeting.locusInfo.parsedLocus = {self: {state: 'LEFT'}};
+          const result = await assert.isRejected(meeting.addMedia());
+
+          assert.instanceOf(result, UserNotJoinedError);
         });
 
         it('should reject promise if user is in lobby ', async () => {
@@ -960,24 +981,29 @@ describe('plugin-meetings', () => {
 
         it('should reset the statsAnalyzer to null if addMedia throws an error', async () => {
           meeting.meetingState = 'ACTIVE';
-          meeting.statsAnalyzer = true;
-          await meeting.addMedia().catch((err) => {
-            assert.exists(err);
-            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: err.message,
-                stack: err.stack,
-                code: err.code,
-                turnDiscoverySkippedReason: undefined,
-                turnServerUsed: true
-              }
-            );
+          // setup the mock to return an incomplete object - this will cause addMedia to fail
+          // because some methods (like on() or initiateOffer()) are missing
+          Media.createMediaConnection = sinon.stub().returns({
+            close: sinon.stub(),
           });
+          // set a statsAnalyzer on the meeting so that we can check that it gets reset to null
+          meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
+          const error = await assert.isRejected(meeting.addMedia());
+
+          assert.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
+            }
+          );
         });
 
         it('checks metrics called with skipped reason config', async () => {
@@ -1000,37 +1026,44 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('should reset the peerConnection to null if addMedia throws an error', async () => {
+        it('should reset the webrtcMediaConnection to null if addMedia throws an error', async () => {
           meeting.meetingState = 'ACTIVE';
-          meeting.mediaProperties.peerConnection = true;
-          await meeting.addMedia().catch((err) => {
-            assert.exists(err);
-            assert.isNull(meeting.mediaProperties.peerConnection);
-            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: undefined,
-                turnServerUsed: true
-              }
-            );
+          // setup the mock so that a media connection is created, but its initiateOffer() method fails
+          Media.createMediaConnection = sinon.stub().returns({
+            initiateOffer: sinon.stub().throws(new Error('fake error')),
+            close: sinon.stub(),
           });
+          const result = await assert.isRejected(meeting.addMedia());
+
+          assert.instanceOf(result, Error);
+          assert.isNull(meeting.mediaProperties.webrtcMediaConnection);
+
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, sinon.match({
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: result.message,
+              turnDiscoverySkippedReason: undefined,
+              turnServerUsed: true
+            })
+          );
         });
 
         it('should work the second time addMedia is called in case the first time fails', async () => {
           meeting.meetingState = 'ACTIVE';
 
-          try {
-            await meeting.addMedia();
-            assert.fail('addMedia should have thrown an exception.');
-          }
-          catch (err) {
-            assert.exists(err);
-          }
+          // setup the mock to cause addMedia() to fail
+          Media.createMediaConnection = sinon.stub().returns({
+            initiateOffer: sinon.stub().throws(new Error('fake error')),
+            close: sinon.stub(),
+          });
+
+          await assert.isRejected(meeting.addMedia());
+
+          // reset the mock to a good one, that doesn't fail
+          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
 
           try {
             await meeting.addMedia({
@@ -1044,12 +1077,11 @@ describe('plugin-meetings', () => {
 
         it('if an error occurs after media request has already been sent, and the user waits until the server kicks them out, a UserNotJoinedError should be thrown when attempting to addMedia again', async () => {
           meeting.meetingState = 'ACTIVE';
-          meeting.roap.sendRoapMediaRequest = sinon.stub().returns(new Promise((resolve) => {
-            meeting.mediaProperties.peerConnection.connectionState = CONSTANTS.CONNECTION_STATE.CONNECTED;
-            resolve();
-          }).then(() => {
-            throw new Error('sample error thrown');
-          }));
+          // setup the mock to cause addMedia() to fail
+          Media.createMediaConnection = sinon.stub().returns({
+            initiateOffer: sinon.stub().throws(new Error('fake error')),
+            close: sinon.stub(),
+          });
           await meeting.addMedia().catch((err) => {
             assert.exists(err);
           });
@@ -1062,21 +1094,16 @@ describe('plugin-meetings', () => {
 
         it('if an error occurs after media request has already been sent, and the user does NOT wait until the server kicks them out, the user should be able to addMedia successfully', async () => {
           meeting.meetingState = 'ACTIVE';
-          meeting.roap.sendRoapMediaRequest = sinon.stub().returns(new Promise((resolve) => {
-            meeting.mediaProperties.peerConnection.connectionState = CONSTANTS.CONNECTION_STATE.CONNECTED;
-            resolve();
-          }).then(() => {
-            throw new Error('sample error thrown');
-          }));
+          // setup the mock to cause addMedia() to fail
+          Media.createMediaConnection = sinon.stub().returns({
+            initiateOffer: sinon.stub().throws(new Error('fake error')),
+            close: sinon.stub(),
+          });
           await meeting.addMedia().catch((err) => {
             assert.exists(err);
           });
 
-          meeting.mediaProperties.peerConnection = {};
-          meeting.roap.sendRoapMediaRequest = sinon.stub().returns(new Promise((resolve) => {
-            meeting.mediaProperties.peerConnection.connectionState = CONSTANTS.CONNECTION_STATE.CONNECTED;
-            resolve();
-          }));
+          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
           await meeting.addMedia().catch((err) => {
             assert.fail('No error should appear: ', err);
           });
@@ -1086,7 +1113,6 @@ describe('plugin-meetings', () => {
           meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
 
           meeting.meetingState = 'ACTIVE';
-          MediaUtil.createPeerConnection.resetHistory();
           const media = meeting.addMedia({
             mediaSettings: {}
           });
@@ -1096,12 +1122,10 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.roap.doTurnDiscovery);
           assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false);
           assert.calledOnce(meeting.mediaProperties.setMediaDirection);
-          assert.calledOnce(Media.attachMedia);
+          assert.calledOnce(Media.createMediaConnection);
+          assert.calledWith(Media.createMediaConnection, false, meeting.getMediaConnectionDebugId(), sinon.match({turnServerInfo: undefined}));
           assert.calledOnce(meeting.setMercuryListener);
-          assert.calledOnce(meeting.setRemoteStream);
-          assert.calledOnce(meeting.roap.sendRoapMediaRequest);
-          assert.calledOnce(MediaUtil.createPeerConnection);
-          assert.calledWith(MediaUtil.createPeerConnection, undefined);
+          assert.calledOnce(fakeMediaConnection.initiateOffer);
           /* statsAnalyzer is initiated inside of addMedia so there isn't
           * a good way to mock it without mocking the constructor
           */
@@ -1113,7 +1137,7 @@ describe('plugin-meetings', () => {
           const FAKE_TURN_PASSWORD = 'some-password';
 
           meeting.meetingState = 'ACTIVE';
-          MediaUtil.createPeerConnection.resetHistory();
+          Media.createMediaConnection.resetHistory();
 
 
           meeting.roap.doTurnDiscovery = sinon.stub().resolves({
@@ -1132,31 +1156,39 @@ describe('plugin-meetings', () => {
           await media;
           assert.calledOnce(meeting.roap.doTurnDiscovery);
           assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false);
-          assert.calledOnce(MediaUtil.createPeerConnection);
-          assert.calledWith(MediaUtil.createPeerConnection, {
-            url: FAKE_TURN_URL,
-            username: FAKE_TURN_USER,
-            password: FAKE_TURN_PASSWORD
-          });
+          assert.calledOnce(Media.createMediaConnection);
+          assert.calledWith(Media.createMediaConnection, false, meeting.getMediaConnectionDebugId(), sinon.match({
+            turnServerInfo: {
+              url: FAKE_TURN_URL,
+              username: FAKE_TURN_USER,
+              password: FAKE_TURN_PASSWORD
+            }
+          }));
+          assert.calledOnce(fakeMediaConnection.initiateOffer);
         });
 
-        it('should attach the media and return promise', async () => {
-          meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
+        it('should attach the media and return WebExMeetingsErrors when connection does not reach CONNECTED state', async () => {
           meeting.meetingState = 'ACTIVE';
-          meeting.mediaProperties.peerConnection.connectionState = 'DISCONNECTED';
+          fakeMediaConnection.getConnectionState = sinon.stub().returns(MC.ConnectionState.Connecting);
+          const clock = sinon.useFakeTimers();
           const media = meeting.addMedia({
             mediaSettings: {}
           });
 
+          await clock.tickAsync(4000 /* meetingState timer, hardcoded inside addMedia */ + PC_BAIL_TIMEOUT /* connection state timer */);
+          await testUtils.flushPromises();
+
           assert.exists(media);
           await media.catch((err) => {
             assert.instanceOf(err, WebExMeetingsErrors);
           });
+
+          clock.restore();
         });
 
-        it('should reject if waitForIceConnectedState() rejects', async () => {
+        it('should reject if waitForMediaConnectionConnected() rejects', async () => {
           meeting.meetingState = 'ACTIVE';
-          meeting.mediaProperties.waitForIceConnectedState.rejects(new Error('fake error'));
+          meeting.mediaProperties.waitForMediaConnectionConnected.rejects(new Error('fake error'));
 
           let errorThrown = false;
 
@@ -1346,8 +1378,8 @@ describe('plugin-meetings', () => {
           meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
           meeting.unsetRemoteStream = sinon.stub().returns(true);
           meeting.unsetPeerConnections = sinon.stub().returns(true);
-          meeting.roap.stop = sinon.stub().returns(Promise.resolve());
           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';
@@ -1371,7 +1403,6 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.unsetLocalShareTrack);
           assert.calledOnce(meeting.unsetRemoteTracks);
           assert.calledOnce(meeting.unsetPeerConnections);
-          assert.calledOnce(meeting.roap.stop);
         });
         describe('after audio/video is defined', () => {
           let handleClientRequest;
@@ -1420,9 +1451,9 @@ describe('plugin-meetings', () => {
           });
         });
       });
-      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}];
@@ -1430,7 +1461,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;
@@ -1484,61 +1515,6 @@ describe('plugin-meetings', () => {
           });
         });
 
-        describe('getter: isLocalShareLive', () => {
-          const LIVE = 'live';
-          const ENDED = 'ended';
-          const SENDRECV = 'sendrecv';
-          const RECVONLY = 'reconly';
-          let sandbox;
-          let _direction;
-          let _trackReadyState = ENDED;
-
-          beforeEach(() => {
-            sandbox = sinon.createSandbox();
-            sandbox.stub(meeting.mediaProperties, 'shareTrack').value(true);
-            sandbox.stub(meeting.mediaProperties, 'peerConnection').value({
-              shareTransceiver: {
-                get direction() {
-                  return _direction;
-                },
-                sender: {
-                  track: {
-                    get readyState() {
-                      return _trackReadyState;
-                    }
-                  }
-                }
-              }
-            });
-          });
-
-          afterEach(() => {
-            sandbox.restore();
-            sandbox = null;
-          });
-
-          it('sets isLocalShareLive to true when sharing screen', () => {
-            _direction = SENDRECV;
-            _trackReadyState = LIVE;
-
-            assert.isTrue(meeting.isLocalShareLive);
-          });
-
-          it('sets isLocalShareLive to false when not sharing screen', () => {
-            _direction = RECVONLY;
-            _trackReadyState = ENDED;
-
-            assert.isFalse(meeting.isLocalShareLive);
-          });
-
-          it('sets isLocalShareLive to false when track is live but share direction is recv only', () => {
-            _direction = RECVONLY;
-            _trackReadyState = LIVE;
-
-            assert.isFalse(meeting.isLocalShareLive);
-          });
-        });
-
         describe('stops share immediately', () => {
           let sandbox;
 
@@ -1556,7 +1532,6 @@ describe('plugin-meetings', () => {
             const receiveShare = false;
             const stream = 'stream';
 
-            sandbox.stub(meeting.mediaProperties, 'peerConnection').value({shareTransceiver: true});
             sandbox.stub(MeetingUtil, 'getTrack').returns({videoTrack: true});
             MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve(true));
             sandbox.stub(meeting, 'canUpdateMedia').returns(true);
@@ -1620,42 +1595,6 @@ describe('plugin-meetings', () => {
             sandbox = null;
           });
 
-          it('calls handleShareTrackEnded if sharing is out of sync', async () => {
-            const sendShare = true;
-            const receiveShare = false;
-            const stream = 'stream';
-            const SENDRECV = 'sendrecv';
-            const delay = 1e3;
-
-            MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve(true));
-            MeetingUtil.updateTransceiver = sinon.stub().returns(Promise.resolve(true));
-            sandbox.stub(meeting, 'canUpdateMedia').returns(true);
-            sandbox.stub(MeetingUtil, 'getTrack').returns({videoTrack: null});
-            sandbox.stub(meeting, 'setLocalShareTrack');
-            sandbox.stub(meeting, 'unsetLocalShareTrack');
-            sandbox.stub(meeting, 'checkForStopShare').returns(false);
-
-            sandbox.stub(meeting, 'isLocalShareLive').value(false);
-            sandbox.stub(meeting, 'handleShareTrackEnded');
-            sandbox.stub(meeting.mediaProperties, 'peerConnection').value({
-              shareTransceiver: {
-                direction: SENDRECV
-              }
-            });
-            sandbox.useFakeTimers();
-
-            await meeting.updateShare({
-              sendShare,
-              receiveShare,
-              stream,
-              skipSignalingCheck: true
-            });
-            // simulate the setTimeout in code
-            sandbox.clock.tick(delay);
-
-            assert.calledOnce(meeting.handleShareTrackEnded);
-          });
-
           it('handleShareTrackEnded triggers an event', () => {
             const stream = 'stream';
             const {EVENT_TYPES} = CONSTANTS;
@@ -1917,6 +1856,11 @@ describe('plugin-meetings', () => {
       });
 
       describe('#updateAudio', () => {
+        const FAKE_AUDIO_TRACK = {
+          id: 'fake audio track',
+          getSettings: sinon.stub().returns({}),
+        };
+
         describe('when canUpdateMedia is true', () => {
           beforeEach(() => {
             meeting.canUpdateMedia = sinon.stub().returns(true);
@@ -1924,20 +1868,33 @@ describe('plugin-meetings', () => {
           describe('when options are valid', () => {
             beforeEach(() => {
               MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve());
+              meeting.mediaProperties.mediaDirection = {
+                sendAudio: false,
+                sendVideo: true,
+                sendShare: false,
+                receiveAudio: false,
+                receiveVideo: true,
+                receiveShare: true,
+              };
+              meeting.mediaProperties.webrtcMediaConnection = {updateSendReceiveOptions: sinon.stub()};
+              sinon.stub(MeetingUtil, 'getTrack').returns({audioTrack: FAKE_AUDIO_TRACK});
             });
-            describe('when mediaDirection is undefined', () => {
-              beforeEach(() => {
-                meeting.mediaProperties.mediaDirection = null;
-                MeetingUtil.updateTransceiver = sinon.stub();
+            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('sets previousMediaDirection to an empty object', () => meeting.updateAudio({
-                sendAudio: true,
-                receiveAudio: true
-              }).then(() => {
-                assert.calledOnce(MeetingUtil.updateTransceiver);
-              }));
-            });
+            }));
+          });
+          afterEach(() => {
+            sinon.restore();
           });
         });
       });
@@ -1988,10 +1945,36 @@ describe('plugin-meetings', () => {
         let sandbox;
         const mockLocalStream = {id: 'mock local stream'};
         const mockLocalShare = {id: 'mock local share stream'};
+        const FAKE_TRACKS = {
+          audio: {
+            id: 'fake audio track',
+            getSettings: sinon.stub().returns({}),
+          },
+          video: {
+            id: 'fake video track',
+            getSettings: sinon.stub().returns({}),
+          },
+          screenshareVideo: {
+            id: 'fake share track',
+            getSettings: sinon.stub().returns({}),
+          },
+
+        };
 
         beforeEach(() => {
           sandbox = sinon.createSandbox();
           meeting.mediaProperties.mediaDirection = {sendShare: true};
+          // setup the stub to return the right tracks
+          sandbox.stub(MeetingUtil, 'getTrack').callsFake((stream) => {
+            if (stream === mockLocalStream) {
+              return {audioTrack: FAKE_TRACKS.audio, videoTrack: FAKE_TRACKS.video};
+            }
+            if (stream === mockLocalShare) {
+              return {audioTrack: null, videoTrack: FAKE_TRACKS.screenshareVideo};
+            }
+
+            return {audioTrack: null, videoTrack: null};
+          });
         });
 
         afterEach(() => {
@@ -2011,7 +1994,9 @@ describe('plugin-meetings', () => {
           };
 
           sandbox.stub(meeting, 'canUpdateMedia').returns(false);
-          sandbox.stub(Media, 'updateMedia').resolves();
+          meeting.mediaProperties.webrtcMediaConnection = {
+            updateSendReceiveOptions: sinon.stub().resolves({})
+          };
 
           let myPromiseResolved = false;
 
@@ -2025,18 +2010,30 @@ describe('plugin-meetings', () => {
             });
 
           // verify that nothing was done
-          assert.notCalled(Media.updateMedia);
+          assert.notCalled(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
 
           // now trigger processing of the queue
           meeting.canUpdateMedia.restore();
           sandbox.stub(meeting, 'canUpdateMedia').returns(true);
-          meeting.updateMedia = sinon.stub().returns(Promise.resolve());
 
           meeting.processNextQueuedMediaUpdate();
           await testUtils.flushPromises();
 
-          // and check that meeting.updateMedia is called with the original args
-          assert.calledWith(meeting.updateMedia, {localStream: mockLocalStream, localShare: mockLocalShare, mediaSettings});
+          // 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.isTrue(myPromiseResolved);
         });
       });
@@ -2282,7 +2279,7 @@ describe('plugin-meetings', () => {
           meeting.mediaProperties.mediaDirection = mediaDirection;
           meeting.canUpdateMedia = sinon.stub().returns(true);
           MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve());
-          MeetingUtil.updateTransceiver = sinon.stub().returns(Promise.resolve());
+          meeting.updateVideo = sinon.stub().resolves();
           sinon.stub(MeetingUtil, 'getTrack').returns({videoTrack: fakeTrack});
         });
 
@@ -2842,8 +2839,8 @@ describe('plugin-meetings', () => {
           meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
           meeting.unsetRemoteStream = sinon.stub().returns(true);
           meeting.unsetPeerConnections = sinon.stub().returns(true);
-          meeting.roap.stop = sinon.stub().returns(Promise.resolve());
           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';
@@ -2867,7 +2864,6 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting?.unsetLocalShareTrack);
           assert.calledOnce(meeting?.unsetRemoteTracks);
           assert.calledOnce(meeting?.unsetPeerConnections);
-          assert.calledOnce(meeting?.roap?.stop);
         });
       });
 
@@ -3295,31 +3291,254 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.stopShare);
         });
       });
-      describe('#setRemoteStream', () => {
+      describe('#setupMediaConnectionListeners', () => {
+        let eventListeners;
+
         beforeEach(() => {
+          eventListeners = {};
           meeting.statsAnalyzer = {startAnalyzer: sinon.stub()};
+          meeting.mediaProperties.webrtcMediaConnection = {
+            // mock the on() method and store all the listeners
+            on: sinon.stub().callsFake((event, listener) => {
+              eventListeners[event] = listener;
+            })
+          };
         });
-        it('should trigger a media:ready event when remote stream track ontrack is fired', () => {
-          const pc = {};
 
-          meeting.setRemoteStream(pc);
-          pc.ontrack({track: 'track', transceiver: {mid: '0'}});
+        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]);
+        });
+
+        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});
           assert.equal(TriggerProxy.trigger.getCall(1).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(1).args[3], {type: 'remoteAudio', stream: true});
 
-          pc.ontrack({track: 'track', transceiver: {mid: '1'}});
+          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({track: 'track', type: MC.RemoteTrackType.VIDEO});
           assert.equal(TriggerProxy.trigger.getCall(2).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(2).args[3], {type: 'remoteVideo', stream: true});
 
-          pc.ontrack({transceiver: {mid: '2'}, track: 'track'});
+          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({track: 'track', type: MC.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});
+        });
 
+        describe('should send correct metrics for ROAP_FAILURE event', () => {
+          const fakeErrorMessage = 'test error';
+          const fakeRootCauseName = 'root cause name';
+          const fakeErrorName = 'test error name';
 
-          // special case for safari
-          pc.ontrack({target: {audioTransceiver: {receiver: {track: {id: 'trackId'}}}}, transceiver: {}, track: {id: 'trackId'}});
-          assert.equal(TriggerProxy.trigger.getCall(1).args[2], 'media:ready');
-          assert.deepEqual(TriggerProxy.trigger.getCall(1).args[3], {type: 'remoteAudio', stream: true});
+          beforeEach(() => {
+            meeting.setupMediaConnectionListeners();
+          });
+
+          const checkMetricSent = (event) => {
+            assert.calledOnce(Metrics.postEvent);
+            assert.calledWithMatch(Metrics.postEvent, {event, meetingId: meeting.id, data: {canProceed: false}});
+          };
+
+          const checkBehavioralMetricSent = (metricName, expectedCode, expectedReason, expectedMetadataType) => {
+            assert.calledOnce(Metrics.sendBehavioralMetric);
+            assert.calledWith(
+              Metrics.sendBehavioralMetric,
+              metricName,
+              {
+                code: expectedCode,
+                correlation_id: meeting.correlationId,
+                reason: expectedReason,
+                stack: sinon.match.any
+              },
+              {
+                type: expectedMetadataType
+              }
+            );
+          };
+
+          it('should send metrics for SdpOfferCreationError error', () => {
+            const fakeError = new MC.Errors.SdpOfferCreationError(fakeErrorMessage, {name: fakeErrorName, cause: {name: fakeRootCauseName}});
+
+            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+
+            checkMetricSent(eventType.LOCAL_SDP_GENERATED);
+            checkBehavioralMetricSent(BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE, MC.Errors.ErrorCode.SdpOfferCreationError, fakeErrorMessage, fakeRootCauseName);
+          });
+
+          it('should send metrics for SdpOfferHandlingError error', () => {
+            const fakeError = new MC.Errors.SdpOfferHandlingError(fakeErrorMessage, {name: fakeErrorName, cause: {name: fakeRootCauseName}});
+
+            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+
+            checkMetricSent(eventType.REMOTE_SDP_RECEIVED);
+            checkBehavioralMetricSent(BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE, MC.Errors.ErrorCode.SdpOfferHandlingError, fakeErrorMessage, fakeRootCauseName);
+          });
+
+          it('should send metrics for SdpAnswerHandlingError error', () => {
+            const fakeError = new MC.Errors.SdpAnswerHandlingError(fakeErrorMessage, {name: fakeErrorName, cause: {name: fakeRootCauseName}});
+
+            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+
+            checkMetricSent(eventType.REMOTE_SDP_RECEIVED);
+            checkBehavioralMetricSent(BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE, MC.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});
+
+            eventListeners[MC.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);
+          });
+
+          it('should send metrics for IceGatheringError error', () => {
+            // IceGatheringError is usually without a cause
+            const fakeError = new MC.Errors.IceGatheringError(fakeErrorMessage, {name: fakeErrorName});
+
+            eventListeners[MC.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);
+          });
+        });
+
+        describe('handles MC.Event.ROAP_MESSAGE_TO_SEND correctly', () => {
+          let sendRoapOKStub;
+          let sendRoapMediaRequestStub;
+          let sendRoapAnswerStub;
+          let sendRoapErrorStub;
+
+          beforeEach(() => {
+            sendRoapOKStub = sinon.stub(meeting.roap, 'sendRoapOK').resolves({});
+            sendRoapMediaRequestStub = sinon.stub(meeting.roap, 'sendRoapMediaRequest').resolves({});
+            sendRoapAnswerStub = sinon.stub(meeting.roap, 'sendRoapAnswer').resolves({});
+            sendRoapErrorStub = sinon.stub(meeting.roap, 'sendRoapError').resolves({});
+
+            meeting.setupMediaConnectionListeners();
+          });
+
+          it('handles OK message correctly', () => {
+            eventListeners[MC.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.calledOnce(sendRoapOKStub);
+            assert.calledWith(sendRoapOKStub, {seq: 1, mediaId: meeting.mediaId, correlationId: meeting.correlationId});
+          });
+
+          it('handles OFFER message correctly', () => {
+            eventListeners[MC.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.calledOnce(sendRoapMediaRequestStub);
+            assert.calledWith(sendRoapMediaRequestStub, {
+              seq: 1, sdp: 'fake sdp', tieBreaker: 12345, meeting, reconnect: false
+            });
+          });
+
+          it('handles ANSWER message correctly', () => {
+            eventListeners[MC.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.calledOnce(sendRoapAnswerStub);
+            assert.calledWith(sendRoapAnswerStub, {
+              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]({
+              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'
+            });
+          });
+
+          [MC.ErrorType.CONFLICT, MC.ErrorType.DOUBLECONFLICT].forEach((errorType) =>
+            it(`handles ERROR message indicating glare condition correctly (errorType=${errorType})`, () => {
+              eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+                roapMessage: {
+                  messageType: 'ERROR',
+                  seq: 10,
+                  errorType,
+                  tieBreaker: 12345,
+                }
+              });
+
+              assert.calledOnce(Metrics.sendBehavioralMetric);
+              assert.calledWithMatch(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ROAP_GLARE_CONDITION, {
+                correlation_id: meeting.correlationId,
+                locus_id: meeting.locusUrl.split('/').pop(),
+                sequence: 10
+              });
+
+              assert.calledOnce(sendRoapErrorStub);
+              assert.calledWith(sendRoapErrorStub, {
+                seq: 10, errorType, mediaId: meeting.mediaId, correlationId: meeting.correlationId
+              });
+            }));
+
+          it('handles ERROR message indicating other errors correctly', () => {
+            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+              roapMessage: {
+                messageType: 'ERROR',
+                seq: 10,
+                errorType: MC.ErrorType.FAILED,
+                tieBreaker: 12345,
+              }
+            });
+
+            assert.notCalled(Metrics.sendBehavioralMetric);
+
+            assert.calledOnce(sendRoapErrorStub);
+            assert.calledWith(sendRoapErrorStub, {
+              seq: 10,
+              errorType: MC.ErrorType.FAILED,
+              mediaId: meeting.mediaId,
+              correlationId: meeting.correlationId
+            });
+          });
         });
       });
       describe('#setUpLocusInfoSelfListener', () => {
@@ -3457,22 +3676,34 @@ 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', () => {
@@ -3514,13 +3745,13 @@ describe('plugin-meetings', () => {
         });
       });
       describe('#closePeerConnections', () => {
-        it('should close the peer connections, and return a promise', async () => {
-          PeerConnectionManager.close = sinon.stub().returns(Promise.resolve());
+        it('should close the webrtc media connection, and return a promise', async () => {
+          meeting.mediaProperties.webrtcMediaConnection = {close: sinon.stub()};
           const pcs = meeting.closePeerConnections();
 
           assert.exists(pcs.then);
           await pcs;
-          assert.calledOnce(PeerConnectionManager.close);
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.close);
         });
       });
       describe('#unsetPeerConnections', () => {
@@ -3687,13 +3918,6 @@ describe('plugin-meetings', () => {
           });
         });
       });
-      describe('#setRoapSeq', () => {
-        it('should set the roap seq and return null', () => {
-          assert.equal(-1, meeting.roapSeq);
-          meeting.setRoapSeq(1);
-          assert.equal(meeting.roapSeq, 1);
-        });
-      });
       describe('#setCorrelationId', () => {
         it('should set the correlationId and return undefined', () => {
           assert.ok(meeting.correlationId);
@@ -3763,6 +3987,7 @@ describe('plugin-meetings', () => {
         let canUserLowerAllHandsSpy;
         let canUserLowerSomeoneElsesHandSpy;
         let waitingForOthersToJoinSpy;
+        let handleDataChannelUrlChangeSpy;
 
         beforeEach(() => {
           locusInfoOnSpy = sinon.spy(meeting.locusInfo, 'on');
@@ -3778,6 +4003,7 @@ describe('plugin-meetings', () => {
           bothLeaveAndEndMeetingAvailableSpy = sinon.spy(MeetingUtil, 'bothLeaveAndEndMeetingAvailable');
           canUserLowerSomeoneElsesHandSpy = sinon.spy(MeetingUtil, 'canUserLowerSomeoneElsesHand');
           waitingForOthersToJoinSpy = sinon.spy(MeetingUtil, 'waitingForOthersToJoin');
+          handleDataChannelUrlChangeSpy = sinon.spy(meeting, 'handleDataChannelUrlChange');
         });
 
         afterEach(() => {
@@ -3799,7 +4025,8 @@ describe('plugin-meetings', () => {
 
           const payload = {
             info: {
-              userDisplayHints: ['LOCK_CONTROL_UNLOCK']
+              userDisplayHints: ['LOCK_CONTROL_UNLOCK'],
+              datachannelUrl: 'some url'
             }
           };
 
@@ -3816,6 +4043,7 @@ describe('plugin-meetings', () => {
           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(
             TriggerProxy.trigger,
@@ -3836,6 +4064,118 @@ 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);
@@ -4003,7 +4343,7 @@ describe('plugin-meetings', () => {
                       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) {
@@ -4054,7 +4394,7 @@ 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 {
@@ -4073,7 +4413,7 @@ describe('plugin-meetings', () => {
                     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) {
@@ -4116,7 +4456,7 @@ describe('plugin-meetings', () => {
                 if (beneficiaryId === USER_IDS.ME) {
                   eventTrigger.share.push({
                     eventName: EVENT_TRIGGERS.MEETING_STOPPED_SHARING_LOCAL,
-                    functionName: 'stopFloorRequest'
+                    functionName: 'localShare'
                   });
                 }
                 else {
@@ -4582,6 +4922,93 @@ 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('thumbs_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('thumbs_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('thumbs_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('thumbs_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,
+          });
+        });
+      });
     });
   });
 });