@webex/plugin-meetings 3.0.0 → 3.1.0-next.10

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

@@ -7,11 +7,12 @@ import sinon from 'sinon';
 import * as internalMediaModule from '@webex/internal-media-core';
 import StateMachine from 'javascript-state-machine';
 import uuid from 'uuid';
-import {assert} from '@webex/test-helper-chai';
+import {assert, expect} from '@webex/test-helper-chai';
 import {Credentials, Token, WebexPlugin} from '@webex/webex-core';
 import Support from '@webex/internal-plugin-support';
 import MockWebex from '@webex/test-helper-mock-webex';
 import StaticConfig from '@webex/plugin-meetings/src/common/config';
+import ReconnectionNotStartedError from '@webex/plugin-meetings/src/common/errors/reconnection-not-started';
 import {Defer} from '@webex/common';
 import {
   FLOOR_ACTION,
@@ -43,7 +44,7 @@ import {
   RemoteTrackType,
   MediaType,
 } from '@webex/internal-media-core';
-import {StreamEventNames} from '@webex/media-helpers';
+import {LocalStreamEventNames} from '@webex/media-helpers';
 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';
@@ -99,7 +100,6 @@ import {
   MeetingInfoV2PolicyError,
 } from '../../../../src/meeting-info/meeting-info-v2';
 import {
-  CLIENT_ERROR_CODE_TO_ERROR_PAYLOAD,
   DTLS_HANDSHAKE_FAILED_CLIENT_CODE,
   ICE_FAILED_WITHOUT_TURN_TLS_CLIENT_CODE,
   ICE_FAILED_WITH_TURN_TLS_CLIENT_CODE,
@@ -110,9 +110,7 @@ import CallDiagnosticMetrics from '@webex/internal-plugin-metrics/src/call-diagn
 import {ERROR_DESCRIPTIONS} from '@webex/internal-plugin-metrics/src/call-diagnostic/config';
 import MeetingCollection from '@webex/plugin-meetings/src/meetings/collection';
 
-import {
-  EVENT_TRIGGERS as VOICEAEVENTS,
-} from '@webex/internal-plugin-voicea';
+import {EVENT_TRIGGERS as VOICEAEVENTS} from '@webex/internal-plugin-voicea';
 
 describe('plugin-meetings', () => {
   const logger = {
@@ -613,36 +611,296 @@ describe('plugin-meetings', () => {
           assert.exists(meeting.joinWithMedia);
         });
 
-        describe('resolution', () => {
-          it('should success and return a promise', async () => {
-            meeting.join = sinon.stub().returns(Promise.resolve(test1));
-            meeting.addMedia = sinon.stub().returns(Promise.resolve(test4));
+        const fakeRoapMessage = {id: 'fake TURN discovery message'};
+        const fakeReachabilityResults = {id: 'fake reachability'};
+        const fakeTurnServerInfo = {id: 'fake turn info'};
+        const fakeJoinResult = {id: 'join result'};
 
-            const joinOptions = {correlationId: '12345'};
-            const mediaOptions = {audioEnabled: test1, allowMediaInLobby: true};
+        const joinOptions = {correlationId: '12345'};
+        const mediaOptions = {audioEnabled: true, allowMediaInLobby: true};
 
-            const result = await meeting.joinWithMedia({
-              joinOptions,
-              mediaOptions,
-            });
-            assert.calledOnceWithExactly(meeting.join, joinOptions);
-            assert.calledOnceWithExactly(meeting.addMedia, mediaOptions);
-            assert.deepEqual(result, {join: test1, media: test4});
+        let generateTurnDiscoveryRequestMessageStub;
+        let handleTurnDiscoveryHttpResponseStub;
+        let abortTurnDiscoveryStub;
+
+        beforeEach(() => {
+          meeting.join = sinon.stub().returns(Promise.resolve(fakeJoinResult));
+          meeting.addMedia = sinon.stub().returns(Promise.resolve(test4));
+
+          webex.meetings.reachability.getReachabilityResults.resolves(fakeReachabilityResults);
+
+          generateTurnDiscoveryRequestMessageStub = sinon
+            .stub(meeting.roap, 'generateTurnDiscoveryRequestMessage')
+            .resolves({roapMessage: fakeRoapMessage});
+          handleTurnDiscoveryHttpResponseStub = sinon
+            .stub(meeting.roap, 'handleTurnDiscoveryHttpResponse')
+            .resolves({turnServerInfo: fakeTurnServerInfo, turnDiscoverySkippedReason: undefined});
+          abortTurnDiscoveryStub = sinon.stub(meeting.roap, 'abortTurnDiscovery');
+        });
+
+        it('should work as expected', async () => {
+          const result = await meeting.joinWithMedia({
+            joinOptions,
+            mediaOptions,
+          });
+
+          // check that TURN discovery is done with join and addMedia called
+          assert.calledOnceWithExactly(meeting.join, {
+            ...joinOptions,
+            roapMessage: fakeRoapMessage,
+            reachability: fakeReachabilityResults,
+          });
+          assert.calledOnceWithExactly(generateTurnDiscoveryRequestMessageStub, meeting, true);
+          assert.calledOnceWithExactly(
+            handleTurnDiscoveryHttpResponseStub,
+            meeting,
+            fakeJoinResult
+          );
+          assert.calledOnceWithExactly(meeting.addMedia, mediaOptions, fakeTurnServerInfo);
+
+          assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+
+          // resets joinWithMediaRetryInfo
+          assert.deepEqual(meeting.joinWithMediaRetryInfo, {isRetry: false, prevJoinResponse: undefined});
+        });
+
+        it("should not call handleTurnDiscoveryHttpResponse if we don't send a TURN discovery request with join", async () => {
+          generateTurnDiscoveryRequestMessageStub.resolves({roapMessage: undefined});
+
+          const result = await meeting.joinWithMedia({
+            joinOptions,
+            mediaOptions,
+          });
+
+          // check that TURN discovery is done with join and addMedia called
+          assert.calledOnceWithExactly(meeting.join, {
+            ...joinOptions,
+            roapMessage: undefined,
+            reachability: fakeReachabilityResults,
+          });
+          assert.calledOnceWithExactly(generateTurnDiscoveryRequestMessageStub, meeting, true);
+          assert.notCalled(handleTurnDiscoveryHttpResponseStub);
+          assert.notCalled(abortTurnDiscoveryStub);
+          assert.calledOnceWithExactly(meeting.addMedia, mediaOptions, undefined);
+
+          assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+          assert.equal(meeting.turnServerUsed, false);
+        });
+
+        it('should call abortTurnDiscovery() if we do not get a TURN server info', async () => {
+          handleTurnDiscoveryHttpResponseStub.resolves({
+            turnServerInfo: undefined,
+            turnDiscoverySkippedReason: 'missing http response',
+          });
+
+          const result = await meeting.joinWithMedia({
+            joinOptions,
+            mediaOptions,
+          });
+
+          // check that TURN discovery is done with join and addMedia called
+          assert.calledOnceWithExactly(meeting.join, {
+            ...joinOptions,
+            roapMessage: fakeRoapMessage,
+            reachability: fakeReachabilityResults,
+          });
+          assert.calledOnceWithExactly(generateTurnDiscoveryRequestMessageStub, meeting, true);
+          assert.calledOnceWithExactly(
+            handleTurnDiscoveryHttpResponseStub,
+            meeting,
+            fakeJoinResult
+          );
+          assert.calledOnceWithExactly(abortTurnDiscoveryStub);
+          assert.calledOnceWithExactly(meeting.addMedia, mediaOptions, undefined);
+
+          assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+        });
+
+        it('should reject if join() fails', async () => {
+          const error = new Error('fake');
+          meeting.join = sinon.stub().returns(Promise.reject(error));
+          meeting.locusUrl = null; // when join fails, we end up with null locusUrl
+
+          await assert.isRejected(meeting.joinWithMedia({mediaOptions: {allowMediaInLobby: true}}));
+
+          assert.calledTwice(abortTurnDiscoveryStub);
+
+          assert.calledTwice(Metrics.sendBehavioralMetric);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: undefined,
+              reason: error.message,
+              stack: error.stack,
+              leaveErrorReason: undefined,
+              isRetry: false,
+            },
+            {
+              type: error.name,
+            }
+          );
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: undefined,
+              reason: error.message,
+              stack: error.stack,
+              leaveErrorReason: undefined,
+              isRetry: true,
+            },
+            {
+              type: error.name,
+            }
+          );
+
+          // resets joinWithMediaRetryInfo
+          assert.deepEqual(meeting.joinWithMediaRetryInfo, {isRetry: false, prevJoinResponse: undefined});
+        });
+
+        it('should resolve if join() fails the first time but succeeds the second time', async () => {
+          const error = new Error('fake');
+          meeting.join = sinon.stub().onFirstCall().returns(Promise.reject(error)).onSecondCall().returns(Promise.resolve(fakeJoinResult));
+          const leaveStub = sinon.stub(meeting, 'leave').resolves();
+
+          const result = await meeting.joinWithMedia({
+            joinOptions,
+            mediaOptions,
           });
+
+          assert.calledOnce(abortTurnDiscoveryStub);
+          assert.calledTwice(meeting.join);
+          assert.notCalled(leaveStub);
+
+          assert.calledOnce(Metrics.sendBehavioralMetric);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric.firstCall,
+            BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: error.message,
+              stack: error.stack,
+              leaveErrorReason: undefined,
+              isRetry: false,
+            },
+            {
+              type: error.name,
+            }
+          );
+
+          assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+
+          // resets joinWithMediaRetryInfo
+          assert.deepEqual(meeting.joinWithMediaRetryInfo, {isRetry: false, prevJoinResponse: undefined});
+        });
+
+        it('should fail if called with allowMediaInLobby:false', async () => {
+          meeting.join = sinon.stub().returns(Promise.resolve(test1));
+          meeting.addMedia = sinon.stub().returns(Promise.resolve(test4));
+
+          await assert.isRejected(
+            meeting.joinWithMedia({mediaOptions: {allowMediaInLobby: false}})
+          );
         });
 
-        describe('rejection', () => {
-          it('should error out and return a promise', async () => {
-            meeting.join = sinon.stub().returns(Promise.reject());
-            assert.isRejected(meeting.joinWithMedia({mediaOptions: {allowMediaInLobby: true}}));
+        it('should call leave() if addMedia fails and ignore leave() failure', async () => {
+          const leaveError = new Error('leave error');
+          const addMediaError = new Error('fake addMedia error');
+
+          const leaveStub = sinon.stub(meeting, 'leave').rejects(leaveError);
+          meeting.addMedia = sinon.stub().rejects(addMediaError);
+
+          await assert.isRejected(
+            meeting.joinWithMedia({
+              joinOptions: {resourceId: 'some resource'},
+              mediaOptions: {allowMediaInLobby: true},
+            }),
+            addMediaError
+          );
+
+          assert.calledOnce(leaveStub);
+          assert.calledOnceWithExactly(leaveStub, {
+            resourceId: 'some resource',
+            reason: 'joinWithMedia failure',
           });
 
-          it('should fail if called with allowMediaInLobby:false', async () => {
-            meeting.join = sinon.stub().returns(Promise.resolve(test1));
-            meeting.addMedia = sinon.stub().returns(Promise.resolve(test4));
 
-            assert.isRejected(meeting.joinWithMedia({mediaOptions: {allowMediaInLobby: false}}));
+          // Behavioral metric is sent on both calls of joinWithMedia
+          assert.calledTwice(Metrics.sendBehavioralMetric);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric.firstCall,
+            BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: addMediaError.message,
+              stack: addMediaError.stack,
+              leaveErrorReason: undefined,
+              isRetry: false,
+            },
+            {
+              type: addMediaError.name,
+            }
+          );
+          assert.calledWith(
+            Metrics.sendBehavioralMetric.secondCall,
+            BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: addMediaError.message,
+              stack: addMediaError.stack,
+              leaveErrorReason: leaveError.message,
+              isRetry: true,
+            },
+            {
+              type: addMediaError.name,
+            }
+          );
+        });
+
+        it('should not call leave() if addMedia fails the first time and succeeds the second time and should only call join() once', async () => {
+          const addMediaError = new Error('fake addMedia error');
+          const leaveError = new Error('leave error');
+          const leaveStub = sinon.stub(meeting, 'leave').rejects(leaveError);
+
+          meeting.addMedia = sinon
+            .stub()
+            .onFirstCall()
+            .rejects(addMediaError)
+            .onSecondCall()
+            .resolves(test4);
+
+          const result = await meeting.joinWithMedia({
+            joinOptions,
+            mediaOptions,
           });
+
+          assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+
+          assert.calledOnce(meeting.join);
+          assert.notCalled(leaveStub);
+
+          assert.calledOnce(Metrics.sendBehavioralMetric);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric.firstCall,
+            BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: addMediaError.message,
+              stack: addMediaError.stack,
+              leaveErrorReason: undefined,
+              isRetry: false,
+            },
+            {
+              type: addMediaError.name,
+            }
+          );
         });
       });
 
@@ -664,12 +922,12 @@ describe('plugin-meetings', () => {
           webex.internal.voicea.on = sinon.stub();
           webex.internal.voicea.off = sinon.stub();
           webex.internal.voicea.listenToEvents = sinon.stub();
-          webex.internal.voicea.toggleTranscribing = sinon.stub();
+          webex.internal.voicea.turnOnCaptions = sinon.stub();
         });
 
         it('should subscribe to events for the first time and avoid subscribing for future transcription starts', async () => {
           meeting.joinedWith = {
-            state: 'JOINED'
+            state: 'JOINED',
           };
           meeting.areVoiceaEventsSetup = false;
           meeting.roles = ['MODERATOR'];
@@ -679,27 +937,18 @@ describe('plugin-meetings', () => {
           assert.equal(webex.internal.voicea.on.callCount, 4);
           assert.equal(meeting.areVoiceaEventsSetup, true);
           assert.equal(webex.internal.voicea.listenToEvents.callCount, 1);
-          assert.calledWith(
-            webex.internal.voicea.toggleTranscribing,
-            true,
-          );
+          assert.called(webex.internal.voicea.turnOnCaptions);
 
           await meeting.startTranscription();
           assert.equal(webex.internal.voicea.on.callCount, 4);
           assert.equal(meeting.areVoiceaEventsSetup, true);
           assert.equal(webex.internal.voicea.listenToEvents.callCount, 1);
-          assert.calledTwice(
-            webex.internal.voicea.toggleTranscribing,
-          );
-          assert.calledWith(
-            webex.internal.voicea.toggleTranscribing,
-            true,
-          );
+          assert.calledTwice(webex.internal.voicea.turnOnCaptions);
         });
 
-        it('should listen to events and not toggleTranscribing if the user is not a host', async () => {
+        it('should listen to events and not turnOnCaptions if the user is not a host', async () => {
           meeting.joinedWith = {
-            state: 'JOINED'
+            state: 'JOINED',
           };
           meeting.areVoiceaEventsSetup = false;
           meeting.roles = ['COHOST'];
@@ -709,9 +958,7 @@ describe('plugin-meetings', () => {
           assert.equal(webex.internal.voicea.on.callCount, 4);
           assert.equal(meeting.areVoiceaEventsSetup, true);
           assert.equal(webex.internal.voicea.listenToEvents.callCount, 1);
-          assert.notCalled(
-            webex.internal.voicea.toggleTranscribing
-          );
+          assert.notCalled(webex.internal.voicea.turnOnCaptions);
         });
 
         it("should throw error if request doesn't work", async () => {
@@ -730,7 +977,7 @@ describe('plugin-meetings', () => {
           webex.internal.voicea.on = sinon.stub();
           webex.internal.voicea.off = sinon.stub();
           webex.internal.voicea.listenToEvents = sinon.stub();
-          webex.internal.voicea.toggleTranscribing = sinon.stub();
+          webex.internal.voicea.turnOnCaptions = sinon.stub();
         });
 
         it('should stop listening to voicea events and also trigger a stop event', () => {
@@ -752,7 +999,7 @@ describe('plugin-meetings', () => {
       describe('#setCaptionLanguage', () => {
         beforeEach(() => {
           meeting.isTranscriptionSupported = sinon.stub();
-          meeting.transcription = { languageOptions: {} };
+          meeting.transcription = {languageOptions: {}};
           webex.internal.voicea.on = sinon.stub();
           webex.internal.voicea.off = sinon.stub();
           webex.internal.voicea.setCaptionLanguage = sinon.stub();
@@ -778,23 +1025,23 @@ describe('plugin-meetings', () => {
           const languageCode = 'fr';
 
           meeting.setCaptionLanguage(languageCode).then((resolvedLanguageCode) => {
-            assert.calledWith(
-              webex.internal.voicea.requestLanguage,
+            assert.calledWith(webex.internal.voicea.requestLanguage, languageCode);
+            assert.equal(resolvedLanguageCode, languageCode);
+            assert.equal(
+              meeting.transcription.languageOptions.currentCaptionLanguage,
               languageCode
             );
-            assert.equal(resolvedLanguageCode, languageCode);
-            assert.equal(meeting.transcription.languageOptions.currentCaptionLanguage, languageCode);
             done();
           });
 
           assert.calledOnceWithMatch(
             webex.internal.voicea.on,
-            VOICEAEVENTS.CAPTION_LANGUAGE_UPDATE,
+            VOICEAEVENTS.CAPTION_LANGUAGE_UPDATE
           );
 
           // Trigger the event
           const voiceaListenerLangugeUpdate = webex.internal.voicea.on.getCall(0).args[1];
-          voiceaListenerLangugeUpdate({ statusCode: 200, languageCode });
+          voiceaListenerLangugeUpdate({statusCode: 200, languageCode});
         });
 
         it('should reject if the statusCode in payload is not 200', (done) => {
@@ -802,8 +1049,8 @@ describe('plugin-meetings', () => {
           const languageCode = 'fr';
           const rejectPayload = {
             statusCode: 400,
-            message: 'some error message'
-          }
+            message: 'some error message',
+          };
 
           meeting.setCaptionLanguage(languageCode).catch((payload) => {
             assert.equal(payload, rejectPayload);
@@ -812,20 +1059,19 @@ describe('plugin-meetings', () => {
 
           assert.calledOnceWithMatch(
             webex.internal.voicea.on,
-            VOICEAEVENTS.CAPTION_LANGUAGE_UPDATE,
+            VOICEAEVENTS.CAPTION_LANGUAGE_UPDATE
           );
 
           // Trigger the event
           const voiceaListenerLangugeUpdate = webex.internal.voicea.on.getCall(0).args[1];
           voiceaListenerLangugeUpdate(rejectPayload);
         });
-
       });
 
       describe('#setSpokenLanguage', () => {
         beforeEach(() => {
           meeting.isTranscriptionSupported = sinon.stub();
-          meeting.transcription = { languageOptions: {} };
+          meeting.transcription = {languageOptions: {}};
           webex.internal.voicea.on = sinon.stub();
           webex.internal.voicea.off = sinon.stub();
           webex.internal.voicea.setSpokenLanguage = sinon.stub();
@@ -850,59 +1096,48 @@ describe('plugin-meetings', () => {
           const languageCode = 'fr';
 
           meeting.setSpokenLanguage(languageCode).then((resolvedLanguageCode) => {
-            assert.calledWith(
-              webex.internal.voicea.setSpokenLanguage,
-              languageCode
-            );
+            assert.calledWith(webex.internal.voicea.setSpokenLanguage, languageCode);
             assert.equal(resolvedLanguageCode, languageCode);
             assert.equal(meeting.transcription.languageOptions.currentSpokenLanguage, languageCode);
             done();
           });
 
-          assert.calledOnceWithMatch(
-            webex.internal.voicea.on,
-            VOICEAEVENTS.SPOKEN_LANGUAGE_UPDATE,
-          );
+          assert.calledOnceWithMatch(webex.internal.voicea.on, VOICEAEVENTS.SPOKEN_LANGUAGE_UPDATE);
 
           // Trigger the event
           const voiceaListenerLangugeUpdate = webex.internal.voicea.on.getCall(0).args[1];
-          voiceaListenerLangugeUpdate({ languageCode });
+          voiceaListenerLangugeUpdate({languageCode});
         });
 
         it('should reject if the language code does not exist in payload', (done) => {
           meeting.isTranscriptionSupported.returns(true);
           const languageCode = 'fr';
           const rejectPayload = {
-            'message': 'some error message'
-          }
+            message: 'some error message',
+          };
 
           meeting.setSpokenLanguage(languageCode).catch((payload) => {
             assert.equal(payload, rejectPayload);
             done();
           });
 
-          assert.calledOnceWithMatch(
-            webex.internal.voicea.on,
-            VOICEAEVENTS.SPOKEN_LANGUAGE_UPDATE,
-          );
+          assert.calledOnceWithMatch(webex.internal.voicea.on, VOICEAEVENTS.SPOKEN_LANGUAGE_UPDATE);
 
           // Trigger the event
           const voiceaListenerLangugeUpdate = webex.internal.voicea.on.getCall(0).args[1];
           voiceaListenerLangugeUpdate(rejectPayload);
         });
-
       });
 
       describe('transcription events', () => {
+        beforeEach(() => {
+          meeting.trigger = sinon.stub();
+        });
+
         it('should trigger meeting:caption-received event', () => {
           meeting.voiceaListenerCallbacks[VOICEAEVENTS.NEW_CAPTION]({});
           assert.calledWith(
-            TriggerProxy.trigger,
-            sinon.match.instanceOf(Meeting),
-            {
-              file: 'meeting/index',
-              function: 'setUpVoiceaListeners',
-            },
+            meeting.trigger,
             EVENT_TRIGGERS.MEETING_CAPTION_RECEIVED
           );
         });
@@ -910,12 +1145,7 @@ describe('plugin-meetings', () => {
         it('should trigger meeting:receiveTranscription:started event', () => {
           meeting.voiceaListenerCallbacks[VOICEAEVENTS.VOICEA_ANNOUNCEMENT]({});
           assert.calledWith(
-            TriggerProxy.trigger,
-            sinon.match.instanceOf(Meeting),
-            {
-              file: 'meeting/index',
-              function: 'setUpVoiceaListeners',
-            },
+            meeting.trigger,
             EVENT_TRIGGERS.MEETING_STARTED_RECEIVING_TRANSCRIPTION
           );
         });
@@ -923,12 +1153,7 @@ describe('plugin-meetings', () => {
         it('should trigger meeting:caption-received event', () => {
           meeting.voiceaListenerCallbacks[VOICEAEVENTS.NEW_CAPTION]({});
           assert.calledWith(
-            TriggerProxy.trigger,
-            sinon.match.instanceOf(Meeting),
-            {
-              file: 'meeting/index',
-              function: 'setUpVoiceaListeners',
-            },
+            meeting.trigger,
             EVENT_TRIGGERS.MEETING_CAPTION_RECEIVED
           );
         });
@@ -1134,7 +1359,7 @@ describe('plugin-meetings', () => {
                 file: 'meeting/index',
                 function: 'join',
               },
-              EVENT_TRIGGERS.MEETING_TRANSCRIPTION_CONNECTED,
+              EVENT_TRIGGERS.MEETING_TRANSCRIPTION_CONNECTED
             );
           });
 
@@ -1412,7 +1637,6 @@ describe('plugin-meetings', () => {
       describe('#addMedia', () => {
         const muteStateStub = {
           handleClientRequest: sinon.stub().returns(Promise.resolve(true)),
-          applyClientStateLocally: sinon.stub().returns(Promise.resolve(true)),
         };
 
         let fakeMediaConnection;
@@ -1426,7 +1650,7 @@ describe('plugin-meetings', () => {
           };
           meeting.mediaProperties.setMediaDirection = sinon.stub().returns(true);
           meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
-          meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
+          meeting.mediaProperties.getCurrentConnectionInfo = sinon.stub().resolves({connectionType: 'udp', selectedCandidatePairChanges: 2, numTransports: 1});
           meeting.audio = muteStateStub;
           meeting.video = muteStateStub;
           sinon.stub(Media, 'createMediaConnection').returns(fakeMediaConnection);
@@ -1526,11 +1750,14 @@ describe('plugin-meetings', () => {
               turnServerUsed: true,
               retriedWithTurnServer: false,
               isMultistream: false,
+              isJoinWithMediaRetry: false,
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
+              selectedCandidatePairChanges: 2,
+              numTransports: 1,
             }
           );
         });
@@ -1630,11 +1857,14 @@ describe('plugin-meetings', () => {
               turnServerUsed: true,
               retriedWithTurnServer: false,
               isMultistream: false,
+              isJoinWithMediaRetry: false,
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
+              selectedCandidatePairChanges: 2,
+              numTransports: 1,
             }
           );
         });
@@ -2108,9 +2338,12 @@ describe('plugin-meetings', () => {
               turnServerUsed: true,
               retriedWithTurnServer: true,
               isMultistream: false,
+              isJoinWithMediaRetry: false,
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              selectedCandidatePairChanges: 2,
+              numTransports: 1,
             },
           ]);
 
@@ -2289,8 +2522,11 @@ describe('plugin-meetings', () => {
               correlation_id: meeting.correlationId,
               locus_id: meeting.locusUrl.split('/').pop(),
               connectionType: 'udp',
+              selectedCandidatePairChanges: 2,
+              numTransports: 1,
               isMultistream: false,
               retriedWithTurnServer: true,
+              isJoinWithMediaRetry: false,
             },
           ]);
           meeting.roap.doTurnDiscovery;
@@ -2431,8 +2667,11 @@ describe('plugin-meetings', () => {
               correlation_id: meeting.correlationId,
               locus_id: meeting.locusUrl.split('/').pop(),
               connectionType: 'udp',
+              selectedCandidatePairChanges: 2,
+              numTransports: 1,
               isMultistream: false,
               retriedWithTurnServer: false,
+              isJoinWithMediaRetry: false,
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
             }
@@ -2491,9 +2730,12 @@ describe('plugin-meetings', () => {
               turnServerUsed: true,
               retriedWithTurnServer: false,
               isMultistream: false,
+              isJoinWithMediaRetry: false,
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              selectedCandidatePairChanges: 2,
+              numTransports: 1,
             }
           );
 
@@ -2506,6 +2748,7 @@ describe('plugin-meetings', () => {
 
           beforeEach(async () => {
             meeting.meetingState = 'ACTIVE';
+            meeting.remoteShareInstanceId = '1234';
             prevConfigValue = meeting.config.stats.enableStatsAnalyzer;
 
             meeting.config.stats.enableStatsAnalyzer = true;
@@ -2611,6 +2854,66 @@ describe('plugin-meetings', () => {
             });
           });
 
+          it('REMOTE_MEDIA_STARTED triggers "meeting:media:remote:start" event and sends metrics for share', async () => {
+            statsAnalyzerStub.emit(
+              {file: 'test', function: 'test'},
+              StatsAnalyzerModule.EVENTS.REMOTE_MEDIA_STARTED,
+              {type: 'share'}
+            );
+
+            assert.calledWith(
+              TriggerProxy.trigger,
+              sinon.match.instanceOf(Meeting),
+              {
+                file: 'meeting/index',
+                function: 'addMedia',
+              },
+              EVENT_TRIGGERS.MEETING_MEDIA_REMOTE_STARTED,
+              {
+                type: 'share',
+              }
+            );
+            assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.media.rx.start',
+              payload: {mediaType: 'share', shareInstanceId: meeting.remoteShareInstanceId},
+              options: {
+                meetingId: meeting.id,
+              },
+            });
+
+            assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.media.render.start',
+              payload: {mediaType: 'share', shareInstanceId: meeting.remoteShareInstanceId},
+              options: {
+                meetingId: meeting.id,
+              },
+            });
+          });
+
+          it('REMOTE_MEDIA_STOPPED triggers the right metrics for share', async () => {
+            statsAnalyzerStub.emit(
+              {file: 'test', function: 'test'},
+              StatsAnalyzerModule.EVENTS.REMOTE_MEDIA_STOPPED,
+              {type: 'share'}
+            );
+
+            assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.media.rx.stop',
+              payload: {mediaType: 'share', shareInstanceId: meeting.remoteShareInstanceId},
+              options: {
+                meetingId: meeting.id,
+              },
+            });
+
+            assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.media.render.stop',
+              payload: {mediaType: 'share', shareInstanceId: meeting.remoteShareInstanceId},
+              options: {
+                meetingId: meeting.id,
+              },
+            });
+          });
+
           it('calls submitMQE correctly', async () => {
             const fakeData = {intervalMetadata: {bla: 'bla'}};
 
@@ -2851,13 +3154,14 @@ describe('plugin-meetings', () => {
             meeting.mediaId = 'fake media id';
             meeting.selfUrl = 'selfUrl';
             meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
-            meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
+            meeting.mediaProperties.getCurrentConnectionInfo = sinon.stub().resolves({connectionType: 'udp', selectedCandidatePairChanges: 2, numTransports: 1});
             meeting.setMercuryListener = sinon.stub();
             meeting.locusInfo.onFullLocus = sinon.stub();
             meeting.webex.meetings.geoHintInfo = {regionCode: 'EU', countryCode: 'UK'};
-            meeting.roap.doTurnDiscovery = sinon
-              .stub()
-              .resolves({turnServerInfo: {}, turnDiscoverySkippedReason: 'reachability'});
+            meeting.roap.doTurnDiscovery = sinon.stub().resolves({
+              turnServerInfo: {url: 'turn-url', username: 'turn user', password: 'turn password'},
+              turnDiscoverySkippedReason: 'reachability',
+            });
             meeting.deferSDPAnswer = new Defer();
             meeting.deferSDPAnswer.resolve();
             meeting.webex.meetings.meetingCollection = new MeetingCollection();
@@ -2868,7 +3172,7 @@ describe('plugin-meetings', () => {
             // setup things that are expected to be the same across all the tests and are actually irrelevant for these tests
             expectedDebugId = `MC-${meeting.id.substring(0, 4)}`;
             expectedMediaConnectionConfig = {
-              iceServers: [{urls: undefined, username: '', credential: ''}],
+              iceServers: [{urls: 'turn-url', username: 'turn user', credential: 'turn password'}],
               skipInactiveTransceivers: false,
               requireH264: true,
               sdpMunging: {
@@ -2892,9 +3196,13 @@ describe('plugin-meetings', () => {
               getSettings: sinon.stub().returns({
                 deviceId: 'some device id',
               }),
-              muted: false,
+              userMuted: false,
+              systemMuted: false,
+              get muted() {
+                return this.userMuted || this.systemMuted;
+              },
               setUnmuteAllowed: sinon.stub(),
-              setMuted: sinon.stub(),
+              setUserMuted: sinon.stub(),
               setServerMuted: sinon.stub(),
               outputStream: {
                 getTracks: () => {
@@ -2927,6 +3235,7 @@ describe('plugin-meetings', () => {
               createSendSlot: sinon.stub().returns({
                 publishStream: sinon.stub(),
                 unpublishStream: sinon.stub(),
+                setNamedMediaGroups: sinon.stub(),
               }),
               enableMultistreamAudio: sinon.stub(),
             };
@@ -3128,28 +3437,52 @@ describe('plugin-meetings', () => {
                 if (stream !== undefined) {
                   switch (type) {
                     case 'audio':
-                      assert.calledOnceWithExactly(
-                        meeting.sendSlotManager.getSlot(MediaType.AudioMain).publishStream,
-                        stream
-                      );
+                      if (stream?.readyState === 'ended') {
+                        assert.notCalled(
+                          meeting.sendSlotManager.getSlot(MediaType.AudioMain).publishStream
+                        );
+                      } else {
+                        assert.calledOnceWithExactly(
+                          meeting.sendSlotManager.getSlot(MediaType.AudioMain).publishStream,
+                          stream
+                        );
+                      }
                       break;
                     case 'video':
-                      assert.calledOnceWithExactly(
-                        meeting.sendSlotManager.getSlot(MediaType.VideoMain).publishStream,
-                        stream
-                      );
+                      if (stream?.readyState === 'ended') {
+                        assert.notCalled(
+                          meeting.sendSlotManager.getSlot(MediaType.VideoMain).publishStream
+                        );
+                      } else {
+                        assert.calledOnceWithExactly(
+                          meeting.sendSlotManager.getSlot(MediaType.VideoMain).publishStream,
+                          stream
+                        );
+                      }
                       break;
                     case 'screenShareAudio':
-                      assert.calledOnceWithExactly(
-                        meeting.sendSlotManager.getSlot(MediaType.AudioSlides).publishStream,
-                        stream
-                      );
+                      if (stream?.readyState === 'ended') {
+                        assert.notCalled(
+                          meeting.sendSlotManager.getSlot(MediaType.AudioSlides).publishStream
+                        );
+                      } else {
+                        assert.calledOnceWithExactly(
+                          meeting.sendSlotManager.getSlot(MediaType.AudioSlides).publishStream,
+                          stream
+                        );
+                      }
                       break;
                     case 'screenShareVideo':
-                      assert.calledOnceWithExactly(
-                        meeting.sendSlotManager.getSlot(MediaType.VideoSlides).publishStream,
-                        stream
-                      );
+                      if (stream?.readyState === 'ended') {
+                        assert.notCalled(
+                          meeting.sendSlotManager.getSlot(MediaType.VideoSlides).publishStream
+                        );
+                      } else {
+                        assert.calledOnceWithExactly(
+                          meeting.sendSlotManager.getSlot(MediaType.VideoSlides).publishStream,
+                          stream
+                        );
+                      }
                       break;
                   }
                 }
@@ -3177,7 +3510,7 @@ describe('plugin-meetings', () => {
             }
           };
 
-          it('addMedia() works correctly when media is enabled without tracks to publish', async () => {
+          it('addMedia() works correctly when media is enabled without streams to publish', async () => {
             await meeting.addMedia();
             await simulateRoapOffer();
             await simulateRoapOk();
@@ -3211,6 +3544,7 @@ describe('plugin-meetings', () => {
           });
 
           it('addMedia() works correctly when media is enabled with streams to publish', async () => {
+            const handleDeviceLoggingSpy = sinon.spy(Meeting, 'handleDeviceLogging');
             await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
             await simulateRoapOffer();
             await simulateRoapOk();
@@ -3241,10 +3575,82 @@ describe('plugin-meetings', () => {
 
             // and that these were the only /media requests that were sent
             assert.calledTwice(locusMediaRequestStub);
+
+            assert.calledOnce(handleDeviceLoggingSpy);
+          });
+
+          it('addMedia() works correctly when media is enabled with streams to publish and stream is user muted', async () => {
+            const handleDeviceLoggingSpy = sinon.spy(Meeting, 'handleDeviceLogging');
+            fakeMicrophoneStream.userMuted = true;
+
+            await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
+            await simulateRoapOffer();
+            await simulateRoapOk();
+
+            // check RoapMediaConnection was created correctly
+            checkMediaConnectionCreated({
+              mediaConnectionConfig: expectedMediaConnectionConfig,
+              localStreams: {
+                audio: fakeMicrophoneStream,
+                video: undefined,
+                screenShareVideo: undefined,
+                screenShareAudio: undefined,
+              },
+              direction: {
+                audio: 'sendrecv',
+                video: 'sendrecv',
+                screenShare: 'recvonly',
+              },
+              remoteQualityLevel: 'HIGH',
+              expectedDebugId,
+              meetingId: meeting.id,
+            });
+            // and SDP offer was sent with the right audioMuted/videoMuted values
+            checkSdpOfferSent({audioMuted: true, videoMuted: true});
+            // check OK was sent with the right audioMuted/videoMuted values
+            checkOkSent({audioMuted: true, videoMuted: true});
+
+            // and that these were the only /media requests that were sent
+            assert.calledTwice(locusMediaRequestStub);
+            assert.calledOnce(handleDeviceLoggingSpy);
+          });
+
+          it('addMedia() works correctly when media is enabled with tracks to publish and track is ended', async () => {
+            fakeMicrophoneStream.readyState = 'ended';
+
+            await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
+            await simulateRoapOffer();
+            await simulateRoapOk();
+
+            // check RoapMediaConnection was created correctly
+            checkMediaConnectionCreated({
+              mediaConnectionConfig: expectedMediaConnectionConfig,
+              localStreams: {
+                audio: undefined,
+                video: undefined,
+                screenShareVideo: undefined,
+                screenShareAudio: undefined,
+              },
+              direction: {
+                audio: 'sendrecv',
+                video: 'sendrecv',
+                screenShare: 'recvonly',
+              },
+              remoteQualityLevel: 'HIGH',
+              expectedDebugId,
+              meetingId: meeting.id,
+            });
+            // and SDP offer was sent with the right audioMuted/videoMuted values
+            checkSdpOfferSent({audioMuted: true, videoMuted: true});
+            // check OK was sent with the right audioMuted/videoMuted values
+            checkOkSent({audioMuted: true, videoMuted: true});
+
+            // and that these were the only /media requests that were sent
+            assert.calledTwice(locusMediaRequestStub);
           });
 
-          it('addMedia() works correctly when media is enabled with tracks to publish and track is muted', async () => {
-            fakeMicrophoneStream.muted = true;
+          it('addMedia() works correctly when media is enabled with streams to publish and stream is system muted', async () => {
+            fakeMicrophoneStream.systemMuted = true;
 
             await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
             await simulateRoapOffer();
@@ -3277,7 +3683,8 @@ describe('plugin-meetings', () => {
             assert.calledTwice(locusMediaRequestStub);
           });
 
-          it('addMedia() works correctly when media is disabled with tracks to publish', async () => {
+          it('addMedia() works correctly when media is disabled with streams to publish', async () => {
+            const handleDeviceLoggingSpy = sinon.spy(Meeting, 'handleDeviceLogging');
             await meeting.addMedia({
               localStreams: {microphone: fakeMicrophoneStream},
               audioEnabled: false,
@@ -3311,9 +3718,23 @@ describe('plugin-meetings', () => {
 
             // and that these were the only /media requests that were sent
             assert.calledTwice(locusMediaRequestStub);
+            assert.calledOnce(handleDeviceLoggingSpy);
           });
 
-          it('addMedia() works correctly when media is disabled with no tracks to publish', async () => {
+          it('handleDeviceLogging not called when media is disabled', async () => {
+            const handleDeviceLoggingSpy = sinon.spy(Meeting, 'handleDeviceLogging');
+            await meeting.addMedia({
+              localStreams: {microphone: fakeMicrophoneStream},
+              audioEnabled: false,
+              videoEnabled: false
+            });
+            await simulateRoapOffer();
+            await simulateRoapOk();
+
+            assert.notCalled(handleDeviceLoggingSpy);
+          })
+
+          it('addMedia() works correctly when media is disabled with no streams to publish', async () => {
             await meeting.addMedia({audioEnabled: false});
             await simulateRoapOffer();
             await simulateRoapOk();
@@ -3346,7 +3767,7 @@ describe('plugin-meetings', () => {
             assert.calledTwice(locusMediaRequestStub);
           });
 
-          it('addMedia() works correctly when video is disabled with no tracks to publish', async () => {
+          it('addMedia() works correctly when video is disabled with no streams to publish', async () => {
             await meeting.addMedia({videoEnabled: false});
             await simulateRoapOffer();
             await simulateRoapOk();
@@ -3379,7 +3800,7 @@ describe('plugin-meetings', () => {
             assert.calledTwice(locusMediaRequestStub);
           });
 
-          it('addMedia() works correctly when screen share is disabled with no tracks to publish', async () => {
+          it('addMedia() works correctly when screen share is disabled with no streams to publish', async () => {
             await meeting.addMedia({shareAudioEnabled: false, shareVideoEnabled: false});
             await simulateRoapOffer();
             await simulateRoapOk();
@@ -3480,9 +3901,13 @@ describe('plugin-meetings', () => {
                 const fakeMicrophoneStream2 = {
                   on: sinon.stub(),
                   off: sinon.stub(),
-                  muted: false,
+                  userMuted: false,
+                  systemMuted: false,
+                  get muted() {
+                    return this.userMuted || this.systemMuted;
+                  },
                   setUnmuteAllowed: sinon.stub(),
-                  setMuted: sinon.stub(),
+                  setUserMuted: sinon.stub(),
                   outputStream: {
                     getTracks: () => {
                       return [
@@ -3719,12 +4144,55 @@ describe('plugin-meetings', () => {
           });
 
           [
-            {mute: true, title: 'muting a track before confluence is created'},
-            {mute: false, title: 'unmuting a track before confluence is created'},
+            {mute: true, title: 'user muting a track before confluence is created'},
+            {mute: false, title: 'user unmuting a track before confluence is created'},
+          ].forEach(({mute, title}) =>
+            it(title, async () => {
+              // initialize the microphone mute state to opposite of what we do in the test
+              fakeMicrophoneStream.userMuted = !mute;
+
+              await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
+              await stableState();
+
+              resetHistory();
+
+              assert.equal(
+                fakeMicrophoneStream.on.getCall(0).args[0],
+                LocalStreamEventNames.UserMuteStateChange
+              );
+              const mutedListener = fakeMicrophoneStream.on.getCall(0).args[1];
+              // simulate track being muted
+              fakeMicrophoneStream.userMuted = mute;
+              mutedListener(mute);
+
+              await stableState();
+
+              // nothing should happen
+              assert.notCalled(locusMediaRequestStub);
+              assert.notCalled(fakeRoapMediaConnection.update);
+
+              // now simulate roap offer and ok
+              await simulateRoapOffer();
+              await simulateRoapOk();
+
+              // it should be sent with the right mute status
+              checkSdpOfferSent({audioMuted: mute, videoMuted: true});
+              // check OK was sent with the right audioMuted/videoMuted values
+              checkOkSent({audioMuted: mute, videoMuted: true});
+
+              // nothing else should happen
+              assert.calledTwice(locusMediaRequestStub);
+              assert.notCalled(fakeRoapMediaConnection.update);
+            })
+          );
+
+          [
+            {mute: true, title: 'system muting a track before confluence is created'},
+            {mute: false, title: 'system unmuting a track before confluence is created'},
           ].forEach(({mute, title}) =>
             it(title, async () => {
               // initialize the microphone mute state to opposite of what we do in the test
-              fakeMicrophoneStream.muted = !mute;
+              fakeMicrophoneStream.systemMuted = !mute;
 
               await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
               await stableState();
@@ -3733,10 +4201,11 @@ describe('plugin-meetings', () => {
 
               assert.equal(
                 fakeMicrophoneStream.on.getCall(0).args[0],
-                StreamEventNames.MuteStateChange
+                LocalStreamEventNames.UserMuteStateChange
               );
               const mutedListener = fakeMicrophoneStream.on.getCall(0).args[1];
               // simulate track being muted
+              fakeMicrophoneStream.systemMuted = mute;
               mutedListener(mute);
 
               await stableState();
@@ -6137,6 +6606,65 @@ describe('plugin-meetings', () => {
             checkScreenShareVideoPublished(videoShareStream);
             checkScreenShareAudioPublished(audioShareStream);
           });
+
+          [
+            {
+              endedStream: 'microphone',
+              streams: {
+                microphone: {
+                  readyState: 'ended',
+                },
+                camera: undefined,
+                screenShare: {
+                  audio: undefined,
+                  video: undefined,
+                },
+              },
+            },
+            {
+              endedStream: 'camera',
+              streams: {
+                microphone: undefined,
+                camera: {
+                  readyState: 'ended',
+                },
+                screenShare: {
+                  audio: undefined,
+                  video: undefined,
+                },
+              },
+            },
+            {
+              endedStream: 'screenShare audio',
+              streams: {
+                microphone: undefined,
+                camera: undefined,
+                screenShare: {
+                  audio: {
+                    readyState: 'ended',
+                  },
+                  video: undefined,
+                },
+              },
+            },
+            {
+              endedStream: 'screenShare video',
+              streams: {
+                microphone: undefined,
+                camera: undefined,
+                screenShare: {
+                  audio: undefined,
+                  video: {
+                    readyState: 'ended',
+                  },
+                },
+              },
+            },
+          ].forEach(({endedStream, streams}) => {
+            it(`throws error if readyState of ${endedStream} is ended`, async () => {
+              assert.isRejected(meeting.publishStreams(streams));
+            });
+          });
         });
 
         describe('unpublishStreams', () => {
@@ -6266,6 +6794,31 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#setSendNamedMediaGroup', () => {
+      beforeEach(() => {
+        meeting.sendSlotManager.setNamedMediaGroups = sinon.stub().returns(undefined);
+      });
+      it('should throw error if not audio type', () => {
+        expect(() => meeting.setSendNamedMediaGroup(MediaType.VideoMain, 20)).to.throw(
+          `cannot set send named media group which media type is ${MediaType.VideoMain}`
+        );
+      });
+      it('fails if there is no media connection', () => {
+        meeting.mediaProperties.webrtcMediaConnection = undefined;
+        meeting.setSendNamedMediaGroup('AUDIO-MAIN', 20);
+        assert.notCalled(meeting.sendSlotManager.setNamedMediaGroups);
+      });
+
+      it('success if there is media connection', () => {
+        meeting.isMultistream = true;
+        meeting.mediaProperties.webrtcMediaConnection = true;
+        meeting.setSendNamedMediaGroup('AUDIO-MAIN', 20);
+        assert.calledOnceWithExactly(meeting.sendSlotManager.setNamedMediaGroups, 'AUDIO-MAIN', [
+          {type: 1, value: 20},
+        ]);
+      });
+    });
+
     describe('#enableMusicMode', () => {
       beforeEach(() => {
         meeting.isMultistream = true;
@@ -6362,21 +6915,13 @@ describe('plugin-meetings', () => {
               }),
             };
             meeting.setupMediaConnectionListeners();
-            meeting.deferSDPAnswer = {
-              resolve: sinon.stub(),
-              reject: sinon.stub(),
-            };
             meeting.sdpResponseTimer = '1234';
-            meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
+            sinon.stub(meeting.mediaProperties, 'waitForMediaConnectionConnected').resolves();
 
-            eventListeners[Event.REMOTE_SDP_ANSWER_PROCESSED]();
             meeting.config.reconnection.enabled = true;
             meeting.currentMediaStatus = {audio: true};
             meeting.reconnectionManager = new ReconnectionManager(meeting);
-            meeting.reconnectionManager.reconnect = sinon.stub().returns(Promise.resolve());
-            meeting.reconnectionManager.reset = sinon.stub().returns(true);
-            meeting.reconnectionManager.cleanup = sinon.stub().returns(true);
-            meeting.reconnectionManager.setStatus = sinon.stub();
+            sinon.stub(meeting.reconnectionManager, 'reconnect').returns(Promise.resolve());
           });
 
           it('should throw error if media not established before trying reconnect', async () => {
@@ -6396,87 +6941,72 @@ describe('plugin-meetings', () => {
             }
           });
 
-          it('should trigger reconnection success and send CA metric', async () => {
-            await meeting.reconnect();
+          it('should call the right functions', async () => {
+            const options = {id: 'fake options'};
+            await meeting.reconnect(options);
+
+            sinon.stub(meeting, 'waitForRemoteSDPAnswer').resolves();
 
-            assert.calledWith(
-              TriggerProxy.trigger,
-              sinon.match.instanceOf(Meeting),
-              {file: 'meeting/index', function: 'reconnect'},
-              'meeting:reconnectionSuccess'
-            );
-            assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
-              name: 'client.media.recovered',
-              payload: {
-                recoveredBy: 'new',
-              },
-              options: {
-                meetingId: meeting.id,
-              },
-            });
             assert.calledOnceWithExactly(
-              meeting.reconnectionManager.setStatus,
-              RECONNECTION.STATE.COMPLETE
+              meeting.reconnectionManager.reconnect,
+              options,
+              sinon.match.any
             );
-          });
+            const callback = meeting.reconnectionManager.reconnect.getCalls()[0].args[1];
 
-          it('should reset after reconnection success', async () => {
-            await meeting.reconnect();
-            assert.calledOnce(meeting.reconnectionManager.reset);
+            // call the completion callback
+            assert.isFunction(callback);
+            await callback();
+
+            // check that the right things were called by the callback
+            assert.calledOnceWithExactly(meeting.waitForRemoteSDPAnswer);
+            assert.calledOnceWithExactly(meeting.mediaProperties.waitForMediaConnectionConnected);
           });
         });
 
         describe('unsuccessful reconnect', () => {
+          let logUploadSpy;
+
           beforeEach(() => {
-            meeting.config.reconnection.enabled = true;
+            logUploadSpy = sinon.spy(meeting, 'uploadLogs');
             meeting.currentMediaStatus = {audio: true};
             meeting.reconnectionManager = new ReconnectionManager(meeting);
             meeting.reconnectionManager.reconnect = sinon
               .stub()
               .returns(Promise.reject(new Error()));
-            meeting.reconnectionManager.reset = sinon.stub().returns(true);
           });
 
-          it('should trigger an unsuccessful reconnection', async () => {
+          it('should upload logs on reconnect failure', async () => {
             await assert.isRejected(meeting.reconnect());
             assert.calledWith(
               TriggerProxy.trigger,
               sinon.match.instanceOf(Meeting),
               {file: 'meeting/index', function: 'reconnect'},
-              'meeting:reconnectionFailure',
-              {error: sinon.match.any}
+              EVENTS.REQUEST_UPLOAD_LOGS,
+              sinon.match.instanceOf(Meeting)
             );
           });
 
-          it('should send metrics on reconnect failure', async () => {
+          it('should fail without uploading logs if there is no reconnectionManager', async () => {
+            meeting.reconnectionManager = null;
             await assert.isRejected(meeting.reconnect());
-            assert(Metrics.sendBehavioralMetric.calledOnce);
-            assert.calledWith(
-              Metrics.sendBehavioralMetric,
-              BEHAVIORAL_METRICS.MEETING_RECONNECT_FAILURE,
-              {
-                correlation_id: meeting.correlationId,
-                locus_id: meeting.locusUrl.split('/').pop(),
-                reason: sinon.match.any,
-                stack: sinon.match.any,
-              }
-            );
+            assert.notCalled(logUploadSpy);
           });
 
-          it('should upload logs on reconnect failure', async () => {
+          it('should fail without uploading logs if there is no media established', async () => {
+            meeting.currentMediaStatus = null;
             await assert.isRejected(meeting.reconnect());
-            assert.calledWith(
-              TriggerProxy.trigger,
-              sinon.match.instanceOf(Meeting),
-              {file: 'meeting/index', function: 'reconnect'},
-              EVENTS.REQUEST_UPLOAD_LOGS,
-              sinon.match.instanceOf(Meeting)
-            );
+            assert.notCalled(logUploadSpy);
           });
 
-          it('should reset after an unsuccessful reconnection', async () => {
-            await assert.isRejected(meeting.reconnect());
-            assert.calledOnce(meeting.reconnectionManager.reset);
+          it('should resolve if the error is ReconnectionNotStartedError', async () => {
+            meeting.reconnectionManager.reconnect.returns(
+              Promise.reject(new ReconnectionNotStartedError())
+            );
+            await meeting.reconnect();
+
+            // logs shouldn't be uploaded
+            assert.notCalled(logUploadSpy);
           });
         });
       });
@@ -7336,6 +7866,7 @@ describe('plugin-meetings', () => {
         });
         it('listens to the self admitted guest event', (done) => {
           meeting.stopKeepAlive = sinon.stub();
+          meeting.updateLLMConnection = sinon.stub();
           meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_ADMITTED_GUEST', test1);
           assert.calledOnceWithExactly(meeting.stopKeepAlive);
           assert.calledThrice(TriggerProxy.trigger);
@@ -7346,6 +7877,7 @@ describe('plugin-meetings', () => {
             'meeting:self:guestAdmitted',
             {payload: test1}
           );
+          assert.calledOnce(meeting.updateLLMConnection);
           done();
         });
 
@@ -7682,6 +8214,21 @@ describe('plugin-meetings', () => {
             EVENT_TRIGGERS.MEETING_INTERPRETATION_UPDATE
           );
         });
+
+        it('listens to the locus manual caption update event', () => {
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'CONTROLS_MEETING_MANUAL_CAPTION_UPDATED',
+            {enable: true}
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_MANUAL_CAPTION_UPDATED
+          );
+        });
       });
 
       describe('#setUpLocusUrlListener', () => {
@@ -8267,6 +8814,34 @@ describe('plugin-meetings', () => {
 
           checkParseMeetingInfo(expectedInfoToParse);
         });
+
+        it('should parse meeting info, set values, and return null when permissionToken is not present', () => {
+          meeting.config.experimental = {enableMediaNegotiatedEvent: true};
+          meeting.config.experimental.enableUnifiedMeetings = true;
+          const FAKE_STRING_DESTINATION = 'sipUrl';
+          const FAKE_MEETING_INFO = {
+            conversationUrl: uuid1,
+            locusUrl: url1,
+            meetingJoinUrl: url2,
+            meetingNumber: '12345',
+            sipMeetingUri: test1,
+            sipUrl: test1,
+            owner: test2,
+          };
+
+          meeting.parseMeetingInfo(FAKE_MEETING_INFO, FAKE_STRING_DESTINATION);
+          const expectedInfoToParse = {
+            conversationUrl: uuid1,
+            locusUrl: url1,
+            sipUri: test1,
+            meetingNumber: '12345',
+            meetingJoinUrl: url2,
+            owner: test2,
+          };
+
+          checkParseMeetingInfo(expectedInfoToParse);
+        });
+
         it('should parse interpretation info correctly', () => {
           const parseInterpretationInfo = sinon.spy(MeetingUtil, 'parseInterpretationInfo');
           const mockToggleOnData = {
@@ -9403,9 +9978,16 @@ describe('plugin-meetings', () => {
           it('check triggerAnnotationInfoEvent event', () => {
             TriggerProxy.trigger.reset();
             const annotationInfo = {version: '1', policy: 'Approval'};
-            const expectAnnotationInfo = {annotationInfo, meetingId: meeting.id};
+            const expectAnnotationInfo = {
+              annotationInfo,
+              meetingId: meeting.id,
+              resourceType: 'FILE',
+            };
             meeting.webex.meetings = {};
-            meeting.triggerAnnotationInfoEvent({annotation: annotationInfo}, {});
+            meeting.triggerAnnotationInfoEvent(
+              {annotation: annotationInfo, resourceType: 'FILE'},
+              {}
+            );
             assert.calledWith(
               TriggerProxy.trigger,
               {},
@@ -9419,8 +10001,8 @@ describe('plugin-meetings', () => {
 
             TriggerProxy.trigger.reset();
             meeting.triggerAnnotationInfoEvent(
-              {annotation: annotationInfo},
-              {annotation: annotationInfo}
+              {annotation: annotationInfo, resourceType: 'FILE'},
+              {annotation: annotationInfo, resourceType: 'FILE'}
             );
             assert.notCalled(TriggerProxy.trigger);
 
@@ -9429,10 +10011,11 @@ describe('plugin-meetings', () => {
             const expectAnnotationInfoUpdated = {
               annotationInfo: annotationInfoUpdate,
               meetingId: meeting.id,
+              resourceType: 'FILE',
             };
             meeting.triggerAnnotationInfoEvent(
-              {annotation: annotationInfoUpdate},
-              {annotation: annotationInfo}
+              {annotation: annotationInfoUpdate, resourceType: 'FILE'},
+              {annotation: annotationInfo, resourceType: 'FILE'}
             );
             assert.calledWith(
               TriggerProxy.trigger,
@@ -9446,7 +10029,10 @@ describe('plugin-meetings', () => {
             );
 
             TriggerProxy.trigger.reset();
-            meeting.triggerAnnotationInfoEvent(null, {annotation: annotationInfoUpdate});
+            meeting.triggerAnnotationInfoEvent(null, {
+              annotation: annotationInfoUpdate,
+              resourceType: 'FILE',
+            });
             assert.notCalled(TriggerProxy.trigger);
           });
         });
@@ -9470,6 +10056,11 @@ describe('plugin-meetings', () => {
               'https://board-a.wbx2.com/board/api/v1/channels/977a7330-54f4-11eb-b1ef-91f5eefc7bf3',
           };
 
+          const SHARE_TYPE = {
+            FILE: 'FILE',
+            DESKTOP: 'DESKTOP',
+          };
+
           const DEVICE_URL = {
             LOCAL_WEB: 'my-web-url',
             LOCAL_MAC: 'my-mac-url',
@@ -9481,11 +10072,14 @@ describe('plugin-meetings', () => {
             beneficiaryId = null,
             disposition = null,
             deviceUrlSharing = null,
-            annotation = undefined
+            annotation = undefined,
+            resourceType = undefined
           ) => ({
             beneficiaryId,
             disposition,
             deviceUrlSharing,
+            annotation,
+            resourceType,
           });
           const generateWhiteboard = (
             beneficiaryId = null,
@@ -9504,7 +10098,8 @@ describe('plugin-meetings', () => {
             annotation,
             url,
             shareInstanceId,
-            deviceUrlSharing
+            deviceUrlSharing,
+            resourceType
           ) => {
             const newPayload = cloneDeep(payload);
 
@@ -9538,7 +10133,8 @@ describe('plugin-meetings', () => {
                   beneficiaryId,
                   FLOOR_ACTION.GRANTED,
                   deviceUrlSharing,
-                  annotation
+                  annotation,
+                  resourceType
                 );
 
                 if (isEqual(newPayload.current, newPayload.previous)) {
@@ -9599,6 +10195,7 @@ describe('plugin-meetings', () => {
                         url,
                         shareInstanceId,
                         annotationInfo: undefined,
+                        resourceType: undefined,
                       },
                     });
                   }
@@ -10440,7 +11037,8 @@ describe('plugin-meetings', () => {
                 undefined,
                 undefined,
                 undefined,
-                DEVICE_URL.REMOTE_A
+                DEVICE_URL.REMOTE_A,
+                undefined
               );
               const data2 = generateData(
                 data1.payload,
@@ -10453,9 +11051,39 @@ describe('plugin-meetings', () => {
                 undefined,
                 undefined,
                 undefined,
-                DEVICE_URL.REMOTE_B
+                DEVICE_URL.REMOTE_B,
+                undefined
+              );
+              const data3 = generateData(data2.payload, false, true, USER_IDS.REMOTE_B, undefined);
+
+              payloadTestHelper([data1, data2, data3]);
+            });
+          });
+
+          describe('File Share  --> Desktop Share', () => {
+            it('Scenario #1: remote person A shares file then share desktop', () => {
+              const data1 = generateData(
+                blankPayload,
+                true,
+                true,
+                USER_IDS.ME,
+                undefined,
+                false,
+                undefined,
+                undefined,
+                undefined,
+                undefined,
+                DEVICE_URL.LOCAL_WEB,
+                SHARE_TYPE.FILE
+              );
+              const data2 = generateData(
+                data1.payload,
+                true,
+                false,
+                USER_IDS.ME,
+                SHARE_TYPE.DESKTOP
               );
-              const data3 = generateData(data2.payload, false, true, USER_IDS.REMOTE_B);
+              const data3 = generateData(data2.payload, true, true, USER_IDS.ME);
 
               payloadTestHelper([data1, data2, data3]);
             });