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

package/src/meeting/index.ts

@@ -10,6 +10,8 @@ import {
   ClientEventLeaveReason,
   CallDiagnosticUtils,
 } from '@webex/internal-plugin-metrics';
+import {ClientEvent as RawClientEvent} from '@webex/event-dictionary-ts';
+
 import {
   ConnectionState,
   Errors,
@@ -50,8 +52,13 @@ import {
 import {StatsAnalyzer, EVENTS as StatsAnalyzerEvents} from '../statsAnalyzer';
 import NetworkQualityMonitor from '../networkQualityMonitor';
 import LoggerProxy from '../common/logs/logger-proxy';
+import EventsUtil from '../common/events/util';
 import Trigger from '../common/events/trigger-proxy';
-import Roap from '../roap/index';
+import Roap, {
+  type TurnDiscoveryResult,
+  type TurnServerInfo,
+  type TurnDiscoverySkipReason,
+} from '../roap/index';
 import Media, {type BundlePolicy} from '../media';
 import MediaProperties from '../media/properties';
 import MeetingStateMachine from './state';
@@ -59,6 +66,7 @@ import {createMuteState} from './muteState';
 import LocusInfo from '../locus-info';
 import Metrics from '../metrics';
 import ReconnectionManager from '../reconnection-manager';
+import ReconnectionNotStartedError from '../common/errors/reconnection-not-started';
 import MeetingRequest from './request';
 import Members from '../members/index';
 import MeetingUtil from './util';
@@ -69,8 +77,6 @@ import MediaUtil from '../media/util';
 import {Reactions, SkinTones} from '../reactions/reactions';
 import PasswordError from '../common/errors/password-error';
 import CaptchaError from '../common/errors/captcha-error';
-import ReconnectionError from '../common/errors/reconnection';
-import ReconnectInProgress from '../common/errors/reconnection-in-progress';
 import {
   _CONVERSATION_URL_,
   _INCOMING_,
@@ -110,6 +116,7 @@ import {
   MEETING_PERMISSION_TOKEN_REFRESH_REASON,
   ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT,
   RECONNECTION,
+  NAMED_MEDIA_GROUP_TYPE_AUDIO,
   LANGUAGE_ENGLISH,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
@@ -119,7 +126,6 @@ import {
   MeetingInfoV2CaptchaError,
   MeetingInfoV2PolicyError,
 } from '../meeting-info/meeting-info-v2';
-import BrowserDetection from '../common/browser-detection';
 import {CSI, ReceiveSlotManager} from '../multistream/receiveSlotManager';
 import SendSlotManager from '../multistream/sendSlotManager';
 import {MediaRequestManager} from '../multistream/mediaRequestManager';
@@ -147,8 +153,6 @@ import ControlsOptionsManager from '../controls-options-manager';
 import PermissionError from '../common/errors/permission';
 import {LocusMediaRequest} from './locusMediaRequest';
 
-const {isBrowser} = BrowserDetection();
-
 const logRequest = (request: any, {logText = ''}) => {
   LoggerProxy.logger.info(`${logText} - sending request`);
 
@@ -614,8 +618,8 @@ export default class Meeting extends StatelessWebexPlugin {
   resourceUrl: string;
   selfId: string;
   state: any;
-  localAudioStreamMuteStateHandler: (muted: boolean) => void;
-  localVideoStreamMuteStateHandler: (muted: boolean) => void;
+  localAudioStreamMuteStateHandler: () => void;
+  localVideoStreamMuteStateHandler: () => void;
   localOutputTrackChangeHandler: () => void;
   roles: any[];
   environment: string;
@@ -623,21 +627,23 @@ export default class Meeting extends StatelessWebexPlugin {
   allowMediaInLobby: boolean;
   localShareInstanceId: string;
   remoteShareInstanceId: string;
-  turnDiscoverySkippedReason: string;
+  turnDiscoverySkippedReason: TurnDiscoverySkipReason;
   turnServerUsed: boolean;
   areVoiceaEventsSetup = false;
+
   voiceaListenerCallbacks: object = {
     [VOICEAEVENTS.VOICEA_ANNOUNCEMENT]: (payload: Transcription['languageOptions']) => {
       this.transcription.languageOptions = payload;
-      Trigger.trigger(
-        this,
-        {
+
+      LoggerProxy.logger.debug(
+        `${EventsUtil.getScopeLog({
           file: 'meeting/index',
           function: 'setUpVoiceaListeners',
-        },
-        EVENT_TRIGGERS.MEETING_STARTED_RECEIVING_TRANSCRIPTION,
-        payload
+        })}event#${EVENT_TRIGGERS.MEETING_STARTED_RECEIVING_TRANSCRIPTION}`
       );
+
+      // @ts-ignore
+      this.trigger(EVENT_TRIGGERS.MEETING_STARTED_RECEIVING_TRANSCRIPTION, payload);
     },
     [VOICEAEVENTS.CAPTIONS_TURNED_ON]: () => {
       this.transcription.status = TURN_ON_CAPTION_STATUS.ENABLED;
@@ -650,18 +656,19 @@ export default class Meeting extends StatelessWebexPlugin {
     },
     [VOICEAEVENTS.NEW_CAPTION]: (data) => {
       processNewCaptions({data, meeting: this});
-      Trigger.trigger(
-        this,
-        {
+
+      LoggerProxy.logger.debug(
+        `${EventsUtil.getScopeLog({
           file: 'meeting/index',
           function: 'setUpVoiceaListeners',
-        },
-        EVENT_TRIGGERS.MEETING_CAPTION_RECEIVED,
-        {
-          captions: this.transcription.captions,
-          interimCaptions: this.transcription.interimCaptions,
-        }
+        })}event#${EVENT_TRIGGERS.MEETING_CAPTION_RECEIVED}`
       );
+
+      // @ts-ignore
+      this.trigger(EVENT_TRIGGERS.MEETING_CAPTION_RECEIVED, {
+        captions: this.transcription.captions,
+        interimCaptions: this.transcription.interimCaptions,
+      });
     },
   };
 
@@ -670,6 +677,7 @@ export default class Meeting extends StatelessWebexPlugin {
   private deferSDPAnswer?: Defer; // used for waiting for a response
   private sdpResponseTimer?: ReturnType<typeof setTimeout>;
   private hasMediaConnectionConnectedAtLeastOnce: boolean;
+  private joinWithMediaRetryInfo?: {isRetry: boolean; prevJoinResponse?: any};
 
   /**
    * @param {Object} attrs
@@ -1380,12 +1388,12 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.remoteMediaManager = null;
 
-    this.localAudioStreamMuteStateHandler = (muted: boolean) => {
-      this.audio.handleLocalStreamMuteStateChange(this, muted);
+    this.localAudioStreamMuteStateHandler = () => {
+      this.audio.handleLocalStreamMuteStateChange(this);
     };
 
-    this.localVideoStreamMuteStateHandler = (muted: boolean) => {
-      this.video.handleLocalStreamMuteStateChange(this, muted);
+    this.localVideoStreamMuteStateHandler = () => {
+      this.video.handleLocalStreamMuteStateChange(this);
     };
 
     // The handling of output track changes should be done inside
@@ -1451,6 +1459,15 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     this.hasMediaConnectionConnectedAtLeastOnce = false;
+
+    /**
+     * Information needed for a retry of a call to joinWithMedia
+     * @instance
+     * @type {{isRetry: boolean; prevJoinResponse?: any}}
+     * @private
+     * @memberof Meeting
+     */
+    this.joinWithMediaRetryInfo = {isRetry: false, prevJoinResponse: undefined};
   }
 
   /**
@@ -2393,6 +2410,18 @@ export default class Meeting extends StatelessWebexPlugin {
       }
     );
 
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_MEETING_MANUAL_CAPTION_UPDATED, ({enable}) => {
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setupLocusControlsListener',
+        },
+        EVENT_TRIGGERS.MEETING_MANUAL_CAPTION_UPDATED,
+        {enable}
+      );
+    });
+
     this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_MEETING_BREAKOUT_UPDATED, ({breakout}) => {
       this.breakouts.updateBreakout(breakout);
       Trigger.trigger(
@@ -2518,6 +2547,7 @@ export default class Meeting extends StatelessWebexPlugin {
         {
           annotationInfo: contentShare?.annotation,
           meetingId: this.id,
+          resourceType: contentShare?.resourceType,
         }
       );
     }
@@ -2546,7 +2576,8 @@ export default class Meeting extends StatelessWebexPlugin {
         contentShare.deviceUrlSharing === previousContentShare.deviceUrlSharing &&
         whiteboardShare.beneficiaryId === previousWhiteboardShare?.beneficiaryId &&
         whiteboardShare.disposition === previousWhiteboardShare?.disposition &&
-        whiteboardShare.resourceUrl === previousWhiteboardShare?.resourceUrl
+        whiteboardShare.resourceUrl === previousWhiteboardShare?.resourceUrl &&
+        contentShare.resourceType === previousContentShare?.resourceType
       ) {
         // nothing changed, so ignore
         // (this happens when we steal presentation from remote)
@@ -2668,6 +2699,7 @@ export default class Meeting extends StatelessWebexPlugin {
                   url: contentShare.url,
                   shareInstanceId: this.remoteShareInstanceId,
                   annotationInfo: contentShare.annotation,
+                  resourceType: contentShare.resourceType,
                 }
               );
             };
@@ -2760,6 +2792,7 @@ export default class Meeting extends StatelessWebexPlugin {
             url: contentShare.url,
             shareInstanceId: this.remoteShareInstanceId,
             annotationInfo: contentShare.annotation,
+            resourceType: contentShare.resourceType,
           }
         );
         this.members.locusMediaSharesUpdate(payload);
@@ -3069,6 +3102,7 @@ export default class Meeting extends StatelessWebexPlugin {
           options: {meetingId: this.id},
         });
       }
+      this.updateLLMConnection();
     });
 
     // @ts-ignore - check if MEDIA_INACTIVITY exists
@@ -3127,7 +3161,7 @@ export default class Meeting extends StatelessWebexPlugin {
     });
 
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_MEETING_INTERPRETATION_CHANGED, (payload) => {
-      this.simultaneousInterpretation.updateSelfInterpretation(payload);
+      const targetChanged = this.simultaneousInterpretation.updateSelfInterpretation(payload);
       Trigger.trigger(
         this,
         {
@@ -3136,6 +3170,9 @@ export default class Meeting extends StatelessWebexPlugin {
         },
         EVENT_TRIGGERS.MEETING_INTERPRETATION_UPDATE
       );
+      if (targetChanged && this.mediaProperties.audioStream) {
+        this.setSendNamedMediaGroup(MediaType.AudioMain);
+      }
     });
 
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_ROLES_CHANGED, (payload) => {
@@ -3450,8 +3487,10 @@ export default class Meeting extends StatelessWebexPlugin {
       this.owner =
         locusMeetingObject?.info.owner || meetingInfo?.owner || meetingInfo?.hostId || this.owner;
       this.permissionToken = meetingInfo?.permissionToken;
-      this.setPermissionTokenPayload(meetingInfo?.permissionToken);
-      this.setSelfUserPolicies();
+      if (this.permissionToken) {
+        this.setPermissionTokenPayload(meetingInfo?.permissionToken);
+        this.setSelfUserPolicies();
+      }
       // Need to populate environment when sending CA event
       this.environment = locusMeetingObject?.info.channel || meetingInfo?.channel;
     }
@@ -3557,6 +3596,9 @@ export default class Meeting extends StatelessWebexPlugin {
           canStartTranscribing: MeetingUtil.canStartTranscribing(this.userDisplayHints),
           canStopTranscribing: MeetingUtil.canStopTranscribing(this.userDisplayHints),
           isClosedCaptionActive: MeetingUtil.isClosedCaptionActive(this.userDisplayHints),
+          canStartManualCaption: MeetingUtil.canStartManualCaption(this.userDisplayHints),
+          canStopManualCaption: MeetingUtil.canStopManualCaption(this.userDisplayHints),
+          isManualCaptionActive: MeetingUtil.isManualCaptionActive(this.userDisplayHints),
           isSaveTranscriptsEnabled: MeetingUtil.isSaveTranscriptsEnabled(this.userDisplayHints),
           isWebexAssistantActive: MeetingUtil.isWebexAssistantActive(this.userDisplayHints),
           canViewCaptionPanel: MeetingUtil.canViewCaptionPanel(this.userDisplayHints),
@@ -3887,7 +3929,14 @@ export default class Meeting extends StatelessWebexPlugin {
   private async setLocalAudioStream(localStream?: LocalMicrophoneStream) {
     const oldStream = this.mediaProperties.audioStream;
 
-    oldStream?.off(StreamEventNames.MuteStateChange, this.localAudioStreamMuteStateHandler);
+    oldStream?.off(
+      LocalStreamEventNames.UserMuteStateChange,
+      this.localAudioStreamMuteStateHandler
+    );
+    oldStream?.off(
+      LocalStreamEventNames.SystemMuteStateChange,
+      this.localAudioStreamMuteStateHandler
+    );
     oldStream?.off(LocalStreamEventNames.OutputTrackChange, this.localOutputTrackChangeHandler);
 
     // we don't update this.mediaProperties.mediaDirection.sendAudio, because we always keep it as true to avoid extra SDP exchanges
@@ -3895,7 +3944,14 @@ export default class Meeting extends StatelessWebexPlugin {
 
     this.audio.handleLocalStreamChange(this);
 
-    localStream?.on(StreamEventNames.MuteStateChange, this.localAudioStreamMuteStateHandler);
+    localStream?.on(
+      LocalStreamEventNames.UserMuteStateChange,
+      this.localAudioStreamMuteStateHandler
+    );
+    localStream?.on(
+      LocalStreamEventNames.SystemMuteStateChange,
+      this.localAudioStreamMuteStateHandler
+    );
     localStream?.on(LocalStreamEventNames.OutputTrackChange, this.localOutputTrackChangeHandler);
 
     if (!this.isMultistream || !localStream) {
@@ -3915,7 +3971,14 @@ export default class Meeting extends StatelessWebexPlugin {
   private async setLocalVideoStream(localStream?: LocalCameraStream) {
     const oldStream = this.mediaProperties.videoStream;
 
-    oldStream?.off(StreamEventNames.MuteStateChange, this.localVideoStreamMuteStateHandler);
+    oldStream?.off(
+      LocalStreamEventNames.UserMuteStateChange,
+      this.localVideoStreamMuteStateHandler
+    );
+    oldStream?.off(
+      LocalStreamEventNames.SystemMuteStateChange,
+      this.localVideoStreamMuteStateHandler
+    );
     oldStream?.off(LocalStreamEventNames.OutputTrackChange, this.localOutputTrackChangeHandler);
 
     // we don't update this.mediaProperties.mediaDirection.sendVideo, because we always keep it as true to avoid extra SDP exchanges
@@ -3923,7 +3986,14 @@ export default class Meeting extends StatelessWebexPlugin {
 
     this.video.handleLocalStreamChange(this);
 
-    localStream?.on(StreamEventNames.MuteStateChange, this.localVideoStreamMuteStateHandler);
+    localStream?.on(
+      LocalStreamEventNames.UserMuteStateChange,
+      this.localVideoStreamMuteStateHandler
+    );
+    localStream?.on(
+      LocalStreamEventNames.SystemMuteStateChange,
+      this.localVideoStreamMuteStateHandler
+    );
     localStream?.on(LocalStreamEventNames.OutputTrackChange, this.localOutputTrackChangeHandler);
 
     if (!this.isMultistream || !localStream) {
@@ -3944,14 +4014,17 @@ export default class Meeting extends StatelessWebexPlugin {
   private async setLocalShareVideoStream(localDisplayStream?: LocalDisplayStream) {
     const oldStream = this.mediaProperties.shareVideoStream;
 
-    oldStream?.off(StreamEventNames.MuteStateChange, this.handleShareVideoStreamMuteStateChange);
+    oldStream?.off(
+      LocalStreamEventNames.SystemMuteStateChange,
+      this.handleShareVideoStreamMuteStateChange
+    );
     oldStream?.off(StreamEventNames.Ended, this.handleShareVideoStreamEnded);
     oldStream?.off(LocalStreamEventNames.OutputTrackChange, this.localOutputTrackChangeHandler);
 
     this.mediaProperties.setLocalShareVideoStream(localDisplayStream);
 
     localDisplayStream?.on(
-      StreamEventNames.MuteStateChange,
+      LocalStreamEventNames.SystemMuteStateChange,
       this.handleShareVideoStreamMuteStateChange
     );
     localDisplayStream?.on(StreamEventNames.Ended, this.handleShareVideoStreamEnded);
@@ -4037,10 +4110,24 @@ export default class Meeting extends StatelessWebexPlugin {
   public cleanupLocalStreams() {
     const {audioStream, videoStream, shareAudioStream, shareVideoStream} = this.mediaProperties;
 
-    audioStream?.off(StreamEventNames.MuteStateChange, this.localAudioStreamMuteStateHandler);
+    audioStream?.off(
+      LocalStreamEventNames.UserMuteStateChange,
+      this.localAudioStreamMuteStateHandler
+    );
+    audioStream?.off(
+      LocalStreamEventNames.SystemMuteStateChange,
+      this.localAudioStreamMuteStateHandler
+    );
     audioStream?.off(LocalStreamEventNames.OutputTrackChange, this.localOutputTrackChangeHandler);
 
-    videoStream?.off(StreamEventNames.MuteStateChange, this.localVideoStreamMuteStateHandler);
+    videoStream?.off(
+      LocalStreamEventNames.UserMuteStateChange,
+      this.localVideoStreamMuteStateHandler
+    );
+    videoStream?.off(
+      LocalStreamEventNames.SystemMuteStateChange,
+      this.localVideoStreamMuteStateHandler
+    );
     videoStream?.off(LocalStreamEventNames.OutputTrackChange, this.localOutputTrackChangeHandler);
 
     shareAudioStream?.off(StreamEventNames.Ended, this.handleShareAudioStreamEnded);
@@ -4048,8 +4135,9 @@ export default class Meeting extends StatelessWebexPlugin {
       LocalStreamEventNames.OutputTrackChange,
       this.localOutputTrackChangeHandler
     );
+
     shareVideoStream?.off(
-      StreamEventNames.MuteStateChange,
+      LocalStreamEventNames.SystemMuteStateChange,
       this.handleShareVideoStreamMuteStateChange
     );
     shareVideoStream?.off(StreamEventNames.Ended, this.handleShareVideoStreamEnded);
@@ -4441,47 +4529,112 @@ export default class Meeting extends StatelessWebexPlugin {
    *   }
    * })
    */
-  public joinWithMedia(
+  public async joinWithMedia(
     options: {
       joinOptions?: any;
       mediaOptions?: AddMediaOptions;
     } = {}
   ) {
-    const {mediaOptions, joinOptions} = options;
+    const {mediaOptions, joinOptions = {}} = options;
+    const {isRetry, prevJoinResponse} = this.joinWithMediaRetryInfo;
 
     if (!mediaOptions?.allowMediaInLobby) {
       return Promise.reject(
         new ParameterError('joinWithMedia() can only be used with allowMediaInLobby set to true')
       );
     }
+    this.allowMediaInLobby = true;
 
     LoggerProxy.logger.info('Meeting:index#joinWithMedia called');
 
-    return this.join(joinOptions)
-      .then((joinResponse) =>
-        this.addMedia(mediaOptions).then((mediaResponse) => ({
-          join: joinResponse,
-          media: mediaResponse,
-        }))
-      )
-      .catch((error) => {
-        LoggerProxy.logger.error('Meeting:index#joinWithMedia --> ', error);
+    let joined = false;
+    let joinResponse = prevJoinResponse;
 
-        Metrics.sendBehavioralMetric(
-          BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
-          {
-            correlation_id: this.correlationId,
-            locus_id: this.locusUrl.split('/').pop(),
-            reason: error.message,
-            stack: error.stack,
-          },
-          {
-            type: error.name,
-          }
+    try {
+      let turnServerInfo;
+      let turnDiscoverySkippedReason;
+
+      // @ts-ignore
+      joinOptions.reachability = await this.webex.meetings.reachability.getReachabilityResults();
+      const turnDiscoveryRequest = await this.roap.generateTurnDiscoveryRequestMessage(this, true);
+
+      ({turnDiscoverySkippedReason} = turnDiscoveryRequest);
+      joinOptions.roapMessage = turnDiscoveryRequest.roapMessage;
+
+      if (!joinResponse) {
+        LoggerProxy.logger.info(
+          'Meeting:index#joinWithMedia ---> calling join with joinOptions, ',
+          joinOptions
         );
 
-        return Promise.reject(error);
-      });
+        joinResponse = await this.join(joinOptions);
+      }
+
+      joined = true;
+
+      if (joinOptions.roapMessage) {
+        ({turnServerInfo, turnDiscoverySkippedReason} =
+          await this.roap.handleTurnDiscoveryHttpResponse(this, joinResponse));
+
+        this.turnDiscoverySkippedReason = turnDiscoverySkippedReason;
+        this.turnServerUsed = !!turnServerInfo;
+
+        if (turnServerInfo === undefined) {
+          this.roap.abortTurnDiscovery();
+        }
+      }
+
+      const mediaResponse = await this.addMedia(mediaOptions, turnServerInfo);
+
+      this.joinWithMediaRetryInfo = {isRetry: false, prevJoinResponse: undefined};
+
+      return {
+        join: joinResponse,
+        media: mediaResponse,
+      };
+    } catch (error) {
+      LoggerProxy.logger.error('Meeting:index#joinWithMedia --> ', error);
+
+      let leaveError;
+
+      this.roap.abortTurnDiscovery();
+
+      if (joined && isRetry) {
+        try {
+          await this.leave({resourceId: joinOptions?.resourceId, reason: 'joinWithMedia failure'});
+        } catch (e) {
+          LoggerProxy.logger.error('Meeting:index#joinWithMedia --> leave error', e);
+          leaveError = e;
+        }
+      }
+
+      Metrics.sendBehavioralMetric(
+        BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+        {
+          correlation_id: this.correlationId,
+          locus_id: this.locusUrl?.split('/').pop(), // if join fails, we may end up with no locusUrl
+          reason: error.message,
+          stack: error.stack,
+          leaveErrorReason: leaveError?.message,
+          isRetry,
+        },
+        {
+          type: error.name,
+        }
+      );
+
+      if (!isRetry) {
+        LoggerProxy.logger.warn('Meeting:index#joinWithMedia --> retrying call to joinWithMedia');
+        this.joinWithMediaRetryInfo.isRetry = true;
+        this.joinWithMediaRetryInfo.prevJoinResponse = joinResponse;
+
+        return this.joinWithMedia(options);
+      }
+
+      this.joinWithMediaRetryInfo = {isRetry: false, prevJoinResponse: undefined};
+
+      throw error;
+    }
   }
 
   /**
@@ -4510,90 +4663,28 @@ export default class Meeting extends StatelessWebexPlugin {
       );
     }
 
-    try {
-      LoggerProxy.logger.info('Meeting:index#reconnect --> Validating reconnect ability.');
-      // @ts-ignore
-      this.reconnectionManager.validate();
-    } catch (error) {
-      // Unable to reconnect this call
-      if (error instanceof ReconnectInProgress) {
-        LoggerProxy.logger.info(
-          'Meeting:index#reconnect --> Unable to reconnect, reconnection in progress.'
-        );
-      } else {
-        LoggerProxy.logger.log('Meeting:index#reconnect --> Unable to reconnect.', error);
-      }
-
-      return Promise.resolve();
-    }
-
-    Trigger.trigger(
-      this,
-      {
-        file: 'meeting/index',
-        function: 'reconnect',
-      },
-      EVENT_TRIGGERS.MEETING_RECONNECTION_STARTING
-    );
-
     return this.reconnectionManager
-      .reconnect(options)
-      .then(() => this.waitForRemoteSDPAnswer())
-      .then(() => this.waitForMediaConnectionConnected())
+      .reconnect(options, async () => {
+        await this.waitForRemoteSDPAnswer();
+        await this.waitForMediaConnectionConnected();
+      })
       .then(() => {
-        Trigger.trigger(
-          this,
-          {
-            file: 'meeting/index',
-            function: 'reconnect',
-          },
-          EVENT_TRIGGERS.MEETING_RECONNECTION_SUCCESS
-        );
         LoggerProxy.logger.log('Meeting:index#reconnect --> Meeting reconnect success');
-
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.media.recovered',
-          payload: {
-            recoveredBy: 'new',
-          },
-          options: {
-            meetingId: this.id,
-          },
-        });
-        this.reconnectionManager.setStatus(RECONNECTION.STATE.COMPLETE);
       })
       .catch((error) => {
-        Trigger.trigger(
-          this,
-          {
-            file: 'meeting/index',
-            function: 'reconnect',
-          },
-          EVENT_TRIGGERS.MEETING_RECONNECTION_FAILURE,
-          {
-            error: new ReconnectionError('Reconnection failure event', error),
-          }
-        );
+        if (error instanceof ReconnectionNotStartedError) {
+          LoggerProxy.logger.log('Meeting:index#reconnect --> Meeting reconnect not started');
 
+          return Promise.resolve();
+        }
         LoggerProxy.logger.error('Meeting:index#reconnect --> Meeting reconnect failed', error);
 
-        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_RECONNECT_FAILURE, {
-          correlation_id: this.correlationId,
-          locus_id: this.locusUrl.split('/').pop(),
-          reason: error.message,
-          stack: error.stack,
-        });
-
         this.uploadLogs({
           file: 'meeting/index',
           function: 'reconnect',
         });
 
-        return Promise.reject(new ReconnectionError('Reconnection failure event', error));
-      })
-      .finally(() => {
-        this.reconnectionManager.reset();
+        return Promise.reject(error);
       });
   }
 
@@ -4747,7 +4838,7 @@ export default class Meeting extends StatelessWebexPlugin {
 
         if (this.getCurUserType() === 'host') {
           // @ts-ignore
-          await this.webex.internal.voicea.toggleTranscribing(true, options?.spokenLanguage);
+          await this.webex.internal.voicea.turnOnCaptions(options?.spokenLanguage);
         }
       } catch (error) {
         LoggerProxy.logger.error(`Meeting:index#startTranscription --> ${error}`);
@@ -5604,7 +5695,7 @@ export default class Meeting extends StatelessWebexPlugin {
               logText: `${LOG_HEADER} Roap Offer`,
             }
           ).catch(() => {
-            this.deferSDPAnswer.reject();
+            this.deferSDPAnswer.reject(new Error('failed to send ROAP SDP offer'));
             clearTimeout(this.sdpResponseTimer);
             this.sdpResponseTimer = undefined;
           });
@@ -5951,6 +6042,20 @@ export default class Meeting extends StatelessWebexPlugin {
           meetingId: this.id,
         },
       });
+
+      if (data.type === 'share') {
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.media.render.start',
+          payload: {
+            mediaType: 'share',
+            shareInstanceId: this.remoteShareInstanceId,
+          },
+          options: {
+            meetingId: this.id,
+          },
+        });
+      }
     });
     this.statsAnalyzer.on(StatsAnalyzerEvents.REMOTE_MEDIA_STOPPED, (data) => {
       // @ts-ignore
@@ -5964,6 +6069,20 @@ export default class Meeting extends StatelessWebexPlugin {
           meetingId: this.id,
         },
       });
+
+      if (data.type === 'share') {
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.media.render.stop',
+          payload: {
+            mediaType: 'share',
+            shareInstanceId: this.remoteShareInstanceId,
+          },
+          options: {
+            meetingId: this.id,
+          },
+        });
+      }
     });
   };
 
@@ -6020,6 +6139,7 @@ export default class Meeting extends StatelessWebexPlugin {
 
     // publish the streams
     if (this.mediaProperties.audioStream) {
+      this.setSendNamedMediaGroup(MediaType.AudioMain);
       await this.publishStream(MediaType.AudioMain, this.mediaProperties.audioStream);
     }
     if (this.mediaProperties.videoStream) {
@@ -6069,16 +6189,22 @@ export default class Meeting extends StatelessWebexPlugin {
   private async setUpLocalStreamReferences(localStreams: LocalStreams) {
     const setUpStreamPromises = [];
 
-    if (localStreams?.microphone) {
+    if (localStreams?.microphone && localStreams?.microphone?.readyState !== 'ended') {
       setUpStreamPromises.push(this.setLocalAudioStream(localStreams.microphone));
     }
-    if (localStreams?.camera) {
+    if (localStreams?.camera && localStreams?.camera?.readyState !== 'ended') {
       setUpStreamPromises.push(this.setLocalVideoStream(localStreams.camera));
     }
-    if (localStreams?.screenShare?.video) {
+    if (
+      localStreams?.screenShare?.video &&
+      localStreams?.screenShare?.video?.readyState !== 'ended'
+    ) {
       setUpStreamPromises.push(this.setLocalShareVideoStream(localStreams.screenShare.video));
     }
-    if (localStreams?.screenShare?.audio) {
+    if (
+      localStreams?.screenShare?.audio &&
+      localStreams?.screenShare?.audio?.readyState !== 'ended'
+    ) {
       setUpStreamPromises.push(this.setLocalShareAudioStream(localStreams.screenShare.audio));
     }
 
@@ -6323,6 +6449,44 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   }
 
+  /**
+   * Performs TURN discovery as a separate call to the Locus /media API
+   *
+   * @param {boolean} isRetry
+   * @param {boolean} isForced
+   * @returns {Promise}
+   */
+  private async doTurnDiscovery(isRetry: boolean, isForced: boolean): Promise<TurnDiscoveryResult> {
+    // @ts-ignore
+    const cdl = this.webex.internal.newMetrics.callDiagnosticLatencies;
+
+    // @ts-ignore
+    this.webex.internal.newMetrics.submitInternalEvent({
+      name: 'internal.client.add-media.turn-discovery.start',
+    });
+
+    const turnDiscoveryResult = await this.roap.doTurnDiscovery(this, isRetry, isForced);
+
+    this.turnDiscoverySkippedReason = turnDiscoveryResult?.turnDiscoverySkippedReason;
+    this.turnServerUsed = !this.turnDiscoverySkippedReason;
+
+    // @ts-ignore
+    this.webex.internal.newMetrics.submitInternalEvent({
+      name: 'internal.client.add-media.turn-discovery.end',
+    });
+
+    if (this.turnServerUsed && turnDiscoveryResult.turnServerInfo) {
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_LATENCY, {
+        correlation_id: this.correlationId,
+        latency: cdl.getTurnDiscoveryTime(),
+        turnServerUsed: this.turnServerUsed,
+        retriedWithTurnServer: this.retriedWithTurnServer,
+      });
+    }
+
+    return turnDiscoveryResult;
+  }
+
   /**
    * Does TURN discovery, SDP offer/answer exhange, establishes ICE connection and DTLS handshake.
    *
@@ -6330,43 +6494,21 @@ export default class Meeting extends StatelessWebexPlugin {
    * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
    * @param {BundlePolicy} [bundlePolicy]
    * @param {boolean} [isForced] - let isForced be true to do turn discovery regardless of reachability results
+   * @param {TurnServerInfo} [turnServerInfo]
    * @returns {Promise<void>}
    */
   private async establishMediaConnection(
     remoteMediaManagerConfig?: RemoteMediaManagerConfiguration,
     bundlePolicy?: BundlePolicy,
-    isForced?: boolean
+    isForced?: boolean,
+    turnServerInfo?: TurnServerInfo
   ): Promise<void> {
     const LOG_HEADER = 'Meeting:index#addMedia():establishMediaConnection -->';
-    // @ts-ignore
-    const cdl = this.webex.internal.newMetrics.callDiagnosticLatencies;
     const isRetry = this.retriedWithTurnServer;
 
     try {
-      // @ts-ignore
-      this.webex.internal.newMetrics.submitInternalEvent({
-        name: 'internal.client.add-media.turn-discovery.start',
-      });
-
-      const turnDiscoveryObject = await this.roap.doTurnDiscovery(this, isRetry, isForced);
-
-      this.turnDiscoverySkippedReason = turnDiscoveryObject?.turnDiscoverySkippedReason;
-      this.turnServerUsed = !this.turnDiscoverySkippedReason;
-
-      // @ts-ignore
-      this.webex.internal.newMetrics.submitInternalEvent({
-        name: 'internal.client.add-media.turn-discovery.end',
-      });
-
-      const {turnServerInfo} = turnDiscoveryObject;
-
-      if (this.turnServerUsed && turnServerInfo) {
-        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_LATENCY, {
-          correlation_id: this.correlationId,
-          latency: cdl.getTurnDiscoveryTime(),
-          turnServerUsed: this.turnServerUsed,
-          retriedWithTurnServer: this.retriedWithTurnServer,
-        });
+      if (!turnServerInfo) {
+        ({turnServerInfo} = await this.doTurnDiscovery(isRetry, isForced));
       }
 
       const mc = await this.createMediaConnection(turnServerInfo, bundlePolicy);
@@ -6385,6 +6527,11 @@ export default class Meeting extends StatelessWebexPlugin {
           RemoteMediaManagerEvent.AudioCreated,
           EVENT_TRIGGERS.REMOTE_MEDIA_AUDIO_CREATED
         );
+        this.forwardEvent(
+          this.remoteMediaManager,
+          RemoteMediaManagerEvent.InterpretationAudioCreated,
+          EVENT_TRIGGERS.REMOTE_MEDIA_INTERPRETATION_AUDIO_CREATED
+        );
         this.forwardEvent(
           this.remoteMediaManager,
           RemoteMediaManagerEvent.ScreenShareAudioCreated,
@@ -6478,15 +6625,21 @@ export default class Meeting extends StatelessWebexPlugin {
    * Creates a media connection to the server. Media connection is required for sending or receiving any audio/video.
    *
    * @param {AddMediaOptions} options
+   * @param {TurnServerInfo} turnServerInfo - TURN server information (used only internally by the SDK)
    * @returns {Promise<void>}
    * @public
    * @memberof Meeting
    */
-  async addMedia(options: AddMediaOptions = {}): Promise<void> {
+  async addMedia(
+    options: AddMediaOptions = {},
+    turnServerInfo: TurnServerInfo = undefined
+  ): Promise<void> {
     this.retriedWithTurnServer = false;
     this.hasMediaConnectionConnectedAtLeastOnce = false;
     const LOG_HEADER = 'Meeting:index#addMedia -->';
-    LoggerProxy.logger.info(`${LOG_HEADER} called with: ${JSON.stringify(options)}`);
+    LoggerProxy.logger.info(
+      `${LOG_HEADER} called with: ${JSON.stringify(options)}, ${JSON.stringify(turnServerInfo)}`
+    );
 
     if (options.allowMediaInLobby !== true && this.meetingState !== FULL_STATE.ACTIVE) {
       throw new MeetingNotActiveError();
@@ -6504,14 +6657,13 @@ export default class Meeting extends StatelessWebexPlugin {
       shareVideoEnabled = true,
       remoteMediaManagerConfig,
       bundlePolicy,
-      allowMediaInLobby,
     } = options;
 
     this.allowMediaInLobby = options?.allowMediaInLobby;
 
     // If the user is unjoined or guest waiting in lobby dont allow the user to addMedia
     // @ts-ignore - isUserUnadmitted coming from SelfUtil
-    if (this.isUserUnadmitted && !this.wirelessShare && !allowMediaInLobby) {
+    if (this.isUserUnadmitted && !this.wirelessShare && !this.allowMediaInLobby) {
       throw new UserInLobbyError();
     }
 
@@ -6580,15 +6732,25 @@ export default class Meeting extends StatelessWebexPlugin {
 
       this.createStatsAnalyzer();
 
-      await this.establishMediaConnection(remoteMediaManagerConfig, bundlePolicy, false);
+      await this.establishMediaConnection(
+        remoteMediaManagerConfig,
+        bundlePolicy,
+        false,
+        turnServerInfo
+      );
 
-      await Meeting.handleDeviceLogging();
+      if (audioEnabled || videoEnabled) {
+        await Meeting.handleDeviceLogging();
+      } else {
+        LoggerProxy.logger.info(`${LOG_HEADER} device logging not required`);
+      }
 
       if (this.mediaProperties.hasLocalShareStream()) {
         await this.enqueueScreenShareFloorRequest();
       }
 
-      const connectionType = await this.mediaProperties.getCurrentConnectionType();
+      const {connectionType, selectedCandidatePairChanges, numTransports} =
+        await this.mediaProperties.getCurrentConnectionInfo();
       // @ts-ignore
       const reachabilityStats = await this.webex.meetings.reachability.getReachabilityMetrics();
 
@@ -6596,8 +6758,11 @@ export default class Meeting extends StatelessWebexPlugin {
         correlation_id: this.correlationId,
         locus_id: this.locusUrl.split('/').pop(),
         connectionType,
+        selectedCandidatePairChanges,
+        numTransports,
         isMultistream: this.isMultistream,
         retriedWithTurnServer: this.retriedWithTurnServer,
+        isJoinWithMediaRetry: this.joinWithMediaRetryInfo.isRetry,
         ...reachabilityStats,
       });
       // @ts-ignore
@@ -6619,16 +6784,22 @@ export default class Meeting extends StatelessWebexPlugin {
       // @ts-ignore
       const reachabilityMetrics = await this.webex.meetings.reachability.getReachabilityMetrics();
 
+      const {selectedCandidatePairChanges, numTransports} =
+        await this.mediaProperties.getCurrentConnectionInfo();
+
       Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
         correlation_id: this.correlationId,
         locus_id: this.locusUrl.split('/').pop(),
         reason: error.message,
         stack: error.stack,
         code: error.code,
+        selectedCandidatePairChanges,
+        numTransports,
         turnDiscoverySkippedReason: this.turnDiscoverySkippedReason,
         turnServerUsed: this.turnServerUsed,
         retriedWithTurnServer: this.retriedWithTurnServer,
         isMultistream: this.isMultistream,
+        isJoinWithMediaRetry: this.joinWithMediaRetryInfo.isRetry,
         signalingState:
           this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
             ?.signalingState ||
@@ -7774,9 +7945,9 @@ export default class Meeting extends StatelessWebexPlugin {
 
   /**
    *
-   * @returns {string} one of 'attendee','host','cohost', returns the user type of the current user
+   * @returns {string} one of 'panelist', 'attendee', 'host', 'cohost', returns the user type of the current user
    */
-  getCurUserType() {
+  getCurUserType(): RawClientEvent['userType'] | null {
     const {roles} = this;
     if (roles) {
       if (roles.includes(SELF_ROLES.MODERATOR)) {
@@ -7785,8 +7956,8 @@ export default class Meeting extends StatelessWebexPlugin {
       if (roles.includes(SELF_ROLES.COHOST)) {
         return 'cohost';
       }
-      if (roles.includes(SELF_ROLES.PRESENTER)) {
-        return 'presenter';
+      if (roles.includes(SELF_ROLES.PANELIST)) {
+        return 'panelist';
       }
       if (roles.includes(SELF_ROLES.ATTENDEE)) {
         return 'attendee';
@@ -8096,6 +8267,33 @@ export default class Meeting extends StatelessWebexPlugin {
       });
   }
 
+  /**
+   * set sending named media group which the audio should send to
+   * @param {MediaType} mediaType of the stream
+   * @param {number} languageCode of the stream
+   * @returns {void}
+   */
+  public setSendNamedMediaGroup(mediaType: MediaType, languageCode = 0): void {
+    if (mediaType !== MediaType.AudioMain) {
+      throw new Error(`cannot set send named media group which media type is ${mediaType}`);
+    }
+
+    const value = languageCode || this.simultaneousInterpretation.getTargetLanguageCode();
+    let groups = [];
+
+    if (value) {
+      groups = [
+        {
+          type: NAMED_MEDIA_GROUP_TYPE_AUDIO,
+          value,
+        },
+      ];
+    }
+    if (this.isMultistream && this.mediaProperties.webrtcMediaConnection) {
+      this.sendSlotManager.setNamedMediaGroups(mediaType, groups);
+    }
+  }
+
   /**
    * Publishes a stream.
    *
@@ -8164,6 +8362,17 @@ export default class Meeting extends StatelessWebexPlugin {
       return;
     }
 
+    if (
+      streams?.microphone?.readyState === 'ended' ||
+      streams?.camera?.readyState === 'ended' ||
+      streams?.screenShare?.audio?.readyState === 'ended' ||
+      streams?.screenShare?.video?.readyState === 'ended'
+    ) {
+      throw new Error(
+        `Attempted to publish stream with ended readyState, correlationId=${this.correlationId}`
+      );
+    }
+
     let floorRequestNeeded = false;
 
     // Screenshare Audio is supported only in multi stream. So we check for screenshare audio presence only if it's a multi stream meeting