@webex/plugin-meetings 3.3.1 → 3.4.0

package/src/meeting/index.ts

@@ -9,6 +9,7 @@ import {
   ClientEvent,
   ClientEventLeaveReason,
   CallDiagnosticUtils,
+  CALL_DIAGNOSTIC_CONFIG,
 } from '@webex/internal-plugin-metrics';
 import {ClientEvent as RawClientEvent} from '@webex/event-dictionary-ts';
 
@@ -16,11 +17,13 @@ import {
   ConnectionState,
   Errors,
   ErrorType,
-  Event,
+  MediaConnectionEventNames,
   MediaContent,
   MediaType,
   RemoteTrackType,
   RoapMessage,
+  StatsAnalyzer,
+  StatsAnalyzerEventNames,
 } from '@webex/internal-media-core';
 
 import {
@@ -40,6 +43,7 @@ import {
   TURN_ON_CAPTION_STATUS,
   type MeetingTranscriptPayload,
 } from '@webex/internal-plugin-voicea';
+
 import {processNewCaptions} from './voicea-meeting';
 
 import {
@@ -50,7 +54,6 @@ import {
   AddMediaFailed,
 } from '../common/errors/webex-errors';
 
-import {StatsAnalyzer, EVENTS as StatsAnalyzerEvents} from '../statsAnalyzer';
 import NetworkQualityMonitor from '../networkQualityMonitor';
 import LoggerProxy from '../common/logs/logger-proxy';
 import EventsUtil from '../common/events/util';
@@ -79,10 +82,9 @@ import {Reactions, SkinTones} from '../reactions/reactions';
 import PasswordError from '../common/errors/password-error';
 import CaptchaError from '../common/errors/captcha-error';
 import {
-  _CONVERSATION_URL_,
+  DESTINATION_TYPE,
   _INCOMING_,
   _JOIN_,
-  _MEETING_LINK_,
   AUDIO,
   CONTENT,
   DISPLAY_HINTS,
@@ -116,9 +118,7 @@ import {
   MEETING_PERMISSION_TOKEN_REFRESH_THRESHOLD_IN_SEC,
   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';
 import ParameterError from '../common/errors/parameter';
@@ -153,6 +153,10 @@ import RecordingController from '../recording-controller';
 import ControlsOptionsManager from '../controls-options-manager';
 import PermissionError from '../common/errors/permission';
 import {LocusMediaRequest} from './locusMediaRequest';
+import {ConnectionStateHandler, ConnectionStateEvent} from './connectionStateHandler';
+
+// default callback so we don't call an undefined function, but in practice it should never be used
+const DEFAULT_ICE_PHASE_CALLBACK = () => 'JOIN_MEETING_FINAL';
 
 const logRequest = (request: any, {logText = ''}) => {
   LoggerProxy.logger.info(`${logText} - sending request`);
@@ -526,7 +530,7 @@ export default class Meeting extends StatelessWebexPlugin {
   conversationUrl: string;
   callStateForMetrics: CallStateForMetrics;
   destination: string;
-  destinationType: string;
+  destinationType: DESTINATION_TYPE;
   deviceUrl: string;
   hostId: string;
   id: string;
@@ -644,6 +648,10 @@ export default class Meeting extends StatelessWebexPlugin {
         })}event#${EVENT_TRIGGERS.MEETING_STARTED_RECEIVING_TRANSCRIPTION}`
       );
 
+      if (this.getCurUserType() !== 'host') {
+        delete payload.spokenLanguages;
+      }
+
       // @ts-ignore
       this.trigger(EVENT_TRIGGERS.MEETING_STARTED_RECEIVING_TRANSCRIPTION, payload);
     },
@@ -674,12 +682,19 @@ export default class Meeting extends StatelessWebexPlugin {
     },
   };
 
-  private retriedWithTurnServer: boolean;
+  private addMediaData: {
+    retriedWithTurnServer: boolean;
+    icePhaseCallback: () => string;
+  };
+
   private sendSlotManager: SendSlotManager = new SendSlotManager(LoggerProxy);
   private deferSDPAnswer?: Defer; // used for waiting for a response
   private sdpResponseTimer?: ReturnType<typeof setTimeout>;
   private hasMediaConnectionConnectedAtLeastOnce: boolean;
   private joinWithMediaRetryInfo?: {isRetry: boolean; prevJoinResponse?: any};
+  private connectionStateHandler?: ConnectionStateHandler;
+  private iceCandidateErrors: Map<string, number>;
+  private iceCandidatesCount: number;
 
   /**
    * @param {Object} attrs
@@ -1445,13 +1460,19 @@ export default class Meeting extends StatelessWebexPlugin {
     this.turnServerUsed = false;
 
     /**
-     * Whether retry was done using TURN Discovery.
+     * Contains information used during the addMedia() operation:
+     * retriedWithTurnServer - whether retry was done using TURN Discovery
+     * icePhaseCallback - callback for determining the value for icePhase when sending failure event to CA
+     *
      * @instance
-     * @type {boolean}
+     * @type {Object}
      * @private
      * @memberof Meeting
      */
-    this.retriedWithTurnServer = false;
+    this.addMediaData = {
+      retriedWithTurnServer: false,
+      icePhaseCallback: DEFAULT_ICE_PHASE_CALLBACK,
+    };
 
     /**
      * Whether or not the media connection has ever successfully connected.
@@ -1470,6 +1491,33 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     this.joinWithMediaRetryInfo = {isRetry: false, prevJoinResponse: undefined};
+
+    /**
+     * Connection state handler
+     * @instance
+     * @type {ConnectionStateHandler}
+     * @private
+     * @memberof Meeting
+     */
+    this.connectionStateHandler = undefined;
+
+    /**
+     * ICE Candidates errors map
+     * @instance
+     * @type {Map<[number, string], number>}
+     * @private
+     * @memberof Meeting
+     */
+    this.iceCandidateErrors = new Map();
+
+    /**
+     * Gathered ICE Candidates count
+     * @instance
+     * @type {number}
+     * @private
+     * @memberof Meeting
+     */
+    this.iceCandidatesCount = 0;
   }
 
   /**
@@ -1718,7 +1766,7 @@ export default class Meeting extends StatelessWebexPlugin {
     }
 
     const isStartingSpaceInstantV2Meeting =
-      this.destinationType === _CONVERSATION_URL_ &&
+      this.destinationType === DESTINATION_TYPE.CONVERSATION_URL &&
       // @ts-ignore - config coming from registerPlugin
       this.config.experimental.enableAdhocMeetings &&
       // @ts-ignore
@@ -1727,7 +1775,9 @@ export default class Meeting extends StatelessWebexPlugin {
     const destination = isStartingSpaceInstantV2Meeting
       ? this.meetingInfo.meetingJoinUrl
       : this.destination;
-    const destinationType = isStartingSpaceInstantV2Meeting ? _MEETING_LINK_ : this.destinationType;
+    const destinationType = isStartingSpaceInstantV2Meeting
+      ? DESTINATION_TYPE.MEETING_LINK
+      : this.destinationType;
 
     const permissionTokenExpiryInfo = this.getPermissionTokenExpiryInfo();
 
@@ -3114,6 +3164,9 @@ export default class Meeting extends StatelessWebexPlugin {
         correlation_id: this.correlationId,
         locus_id: this.locusId,
       });
+      LoggerProxy.logger.info(
+        'Meeting:index#setUpLocusInfoSelfListener --> MEDIA_INACTIVITY received, reconnecting...'
+      );
       this.reconnect();
     });
 
@@ -4242,8 +4295,6 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   public closePeerConnections() {
-    this.locusMediaRequest = undefined;
-
     if (this.mediaProperties.webrtcMediaConnection) {
       if (this.remoteMediaManager) {
         this.remoteMediaManager.stop();
@@ -4556,38 +4607,57 @@ export default class Meeting extends StatelessWebexPlugin {
     try {
       let turnServerInfo;
       let turnDiscoverySkippedReason;
+      let forceTurnDiscovery = false;
 
-      // @ts-ignore
-      joinOptions.reachability = await this.webex.meetings.reachability.getReachabilityResults();
-      const turnDiscoveryRequest = await this.roap.generateTurnDiscoveryRequestMessage(this, true);
+      if (!joinResponse) {
+        // This is the 1st attempt or a retry after join request failed -> we need to do a join with TURN discovery
 
-      ({turnDiscoverySkippedReason} = turnDiscoveryRequest);
-      joinOptions.roapMessage = turnDiscoveryRequest.roapMessage;
+        // @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
         );
 
         joinResponse = await this.join(joinOptions);
-      }
 
-      joined = true;
+        joined = true;
 
-      if (joinOptions.roapMessage) {
-        ({turnServerInfo, turnDiscoverySkippedReason} =
-          await this.roap.handleTurnDiscoveryHttpResponse(this, joinResponse));
+        // if we sent out TURN discovery Roap message with join, process the TURN discovery response
+        if (joinOptions.roapMessage) {
+          ({turnServerInfo, turnDiscoverySkippedReason} =
+            await this.roap.handleTurnDiscoveryHttpResponse(this, joinResponse));
 
-        this.turnDiscoverySkippedReason = turnDiscoverySkippedReason;
-        this.turnServerUsed = !!turnServerInfo;
+          this.turnDiscoverySkippedReason = turnDiscoverySkippedReason;
+          this.turnServerUsed = !!turnServerInfo;
 
-        if (turnServerInfo === undefined) {
-          this.roap.abortTurnDiscovery();
+          if (turnServerInfo === undefined) {
+            this.roap.abortTurnDiscovery();
+          }
         }
+      } else {
+        // This is a retry, when join succeeded but addMedia failed, so we'll just call addMedia() again,
+        // but we need to ensure that it also does a new TURN discovery
+        forceTurnDiscovery = true;
+        joined = true;
       }
 
-      const mediaResponse = await this.addMedia(mediaOptions, turnServerInfo);
+      const mediaResponse = await this.addMediaInternal(
+        () => {
+          return this.joinWithMediaRetryInfo.isRetry ? 'JOIN_MEETING_FINAL' : 'JOIN_MEETING_RETRY';
+        },
+        turnServerInfo,
+        forceTurnDiscovery,
+        mediaOptions
+      );
 
       this.joinWithMediaRetryInfo = {isRetry: false, prevJoinResponse: undefined};
 
@@ -4626,7 +4696,16 @@ export default class Meeting extends StatelessWebexPlugin {
         }
       );
 
-      if (!isRetry) {
+      // if this was the first attempt, let's do a retry
+      let shouldRetry = !isRetry;
+
+      if (CallDiagnosticUtils.isSdpOfferCreationError(error)) {
+        // errors related to offer creation (for example missing H264 codec) will happen again no matter how many times we try,
+        // so there is no point doing a retry
+        shouldRetry = false;
+      }
+
+      if (shouldRetry) {
         LoggerProxy.logger.warn('Meeting:index#joinWithMedia --> retrying call to joinWithMedia');
         this.joinWithMediaRetryInfo.isRetry = true;
         this.joinWithMediaRetryInfo.prevJoinResponse = joinResponse;
@@ -4786,6 +4865,14 @@ export default class Meeting extends StatelessWebexPlugin {
         reject(new Error('Webex Assistant is not enabled/supported'));
       }
 
+      if (this.getCurUserType() !== 'host') {
+        LoggerProxy.logger.error(
+          'Meeting:index#setSpokenLanguage --> Only host can set spoken language'
+        );
+
+        reject(new Error('Only host can set spoken language'));
+      }
+
       try {
         const voiceaListenerLanguageUpdate = (payload) => {
           // @ts-ignore
@@ -4839,10 +4926,8 @@ export default class Meeting extends StatelessWebexPlugin {
           this.setUpVoiceaListeners();
         }
 
-        if (this.getCurUserType() === 'host') {
-          // @ts-ignore
-          await this.webex.internal.voicea.turnOnCaptions(options?.spokenLanguage);
-        }
+        // @ts-ignore
+        await this.webex.internal.voicea.turnOnCaptions(options?.spokenLanguage);
       } catch (error) {
         LoggerProxy.logger.error(`Meeting:index#startTranscription --> ${error}`);
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.RECEIVE_TRANSCRIPTION_FAILURE, {
@@ -5141,6 +5226,8 @@ export default class Meeting extends StatelessWebexPlugin {
     return MeetingUtil.joinMeetingOptions(this, options)
       .then((join) => {
         this.meetingFiniteStateMachine.join();
+        this.setupLocusMediaRequest();
+
         LoggerProxy.logger.log('Meeting:index#join --> Success');
 
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.JOIN_SUCCESS, {
@@ -5233,8 +5320,13 @@ export default class Meeting extends StatelessWebexPlugin {
 
     // @ts-ignore - Fix type
     if (this.webex.internal.llm.isConnected()) {
-      // @ts-ignore - Fix type
-      if (url === this.webex.internal.llm.getLocusUrl() && isJoined) {
+      if (
+        // @ts-ignore - Fix type
+        url === this.webex.internal.llm.getLocusUrl() &&
+        // @ts-ignore - Fix type
+        datachannelUrl === this.webex.internal.llm.getDatachannelUrl() &&
+        isJoined
+      ) {
         return undefined;
       }
       // @ts-ignore - Fix type
@@ -5634,219 +5726,258 @@ export default class Meeting extends StatelessWebexPlugin {
    * @returns {undefined}
    */
   setupSdpListeners = () => {
-    this.mediaProperties.webrtcMediaConnection.on(Event.REMOTE_SDP_ANSWER_PROCESSED, () => {
-      // @ts-ignore
-      const cdl = this.webex.internal.newMetrics.callDiagnosticLatencies;
+    this.mediaProperties.webrtcMediaConnection.on(
+      MediaConnectionEventNames.REMOTE_SDP_ANSWER_PROCESSED,
+      () => {
+        // @ts-ignore
+        const cdl = this.webex.internal.newMetrics.callDiagnosticLatencies;
 
-      // @ts-ignore
-      this.webex.internal.newMetrics.submitClientEvent({
-        name: 'client.media-engine.remote-sdp-received',
-        options: {meetingId: this.id},
-      });
-      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_OFFER_TO_ANSWER_LATENCY, {
-        correlation_id: this.correlationId,
-        latency: cdl.getLocalSDPGenRemoteSDPRecv(),
-        meetingId: this.id,
-      });
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.media-engine.remote-sdp-received',
+          options: {meetingId: this.id},
+        });
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_OFFER_TO_ANSWER_LATENCY, {
+          correlation_id: this.correlationId,
+          latency: cdl.getLocalSDPGenRemoteSDPRecv(),
+          meetingId: this.id,
+        });
 
-      if (this.deferSDPAnswer) {
-        this.deferSDPAnswer.resolve();
-        clearTimeout(this.sdpResponseTimer);
-        this.sdpResponseTimer = undefined;
+        if (this.deferSDPAnswer) {
+          this.deferSDPAnswer.resolve();
+          clearTimeout(this.sdpResponseTimer);
+          this.sdpResponseTimer = undefined;
+        }
       }
-    });
+    );
 
-    this.mediaProperties.webrtcMediaConnection.on(Event.LOCAL_SDP_OFFER_GENERATED, () => {
-      // @ts-ignore
-      this.webex.internal.newMetrics.submitClientEvent({
-        name: 'client.media-engine.local-sdp-generated',
-        options: {meetingId: this.id},
-      });
+    this.mediaProperties.webrtcMediaConnection.on(
+      MediaConnectionEventNames.LOCAL_SDP_OFFER_GENERATED,
+      () => {
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.media-engine.local-sdp-generated',
+          options: {meetingId: this.id},
+        });
 
-      // Instantiate Defer so that the SDP offer/answer exchange timeout can start, see waitForRemoteSDPAnswer()
-      this.deferSDPAnswer = new Defer();
-    });
+        // Instantiate Defer so that the SDP offer/answer exchange timeout can start, see waitForRemoteSDPAnswer()
+        this.deferSDPAnswer = new Defer();
+      }
+    );
 
-    this.mediaProperties.webrtcMediaConnection.on(Event.LOCAL_SDP_ANSWER_GENERATED, () => {
-      // we are sending "remote-sdp-received" only after we've generated the answer - this indicates that we've fully processed that incoming offer
-      // @ts-ignore
-      this.webex.internal.newMetrics.submitClientEvent({
-        name: 'client.media-engine.remote-sdp-received',
-        options: {meetingId: this.id},
-      });
-    });
+    this.mediaProperties.webrtcMediaConnection.on(
+      MediaConnectionEventNames.LOCAL_SDP_ANSWER_GENERATED,
+      () => {
+        // we are sending "remote-sdp-received" only after we've generated the answer - this indicates that we've fully processed that incoming offer
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.media-engine.remote-sdp-received',
+          options: {meetingId: this.id},
+        });
+      }
+    );
   };
 
   setupMediaConnectionListeners = () => {
     this.setupSdpListeners();
 
-    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_STARTED, () => {
+    this.mediaProperties.webrtcMediaConnection.on(MediaConnectionEventNames.ROAP_STARTED, () => {
       this.isRoapInProgress = true;
     });
 
-    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_DONE, () => {
+    this.mediaProperties.webrtcMediaConnection.on(MediaConnectionEventNames.ROAP_DONE, () => {
       this.mediaNegotiatedEvent();
       this.isRoapInProgress = false;
       this.processNextQueuedMediaUpdate();
     });
 
-    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_FAILURE, this.handleRoapFailure);
+    this.mediaProperties.webrtcMediaConnection.on(
+      MediaConnectionEventNames.ROAP_FAILURE,
+      this.handleRoapFailure
+    );
 
-    this.mediaProperties.webrtcMediaConnection.on(Event.ROAP_MESSAGE_TO_SEND, (event) => {
-      const LOG_HEADER = `Meeting:index#setupMediaConnectionListeners.ROAP_MESSAGE_TO_SEND --> correlationId=${this.correlationId}`;
+    this.mediaProperties.webrtcMediaConnection.on(
+      MediaConnectionEventNames.ROAP_MESSAGE_TO_SEND,
+      (event) => {
+        const LOG_HEADER = `Meeting:index#setupMediaConnectionListeners.ROAP_MESSAGE_TO_SEND --> correlationId=${this.correlationId}`;
+
+        switch (event.roapMessage.messageType) {
+          case 'OK':
+            logRequest(
+              this.roap.sendRoapOK({
+                seq: event.roapMessage.seq,
+                mediaId: this.mediaId,
+                correlationId: this.correlationId,
+              }),
+              {
+                logText: `${LOG_HEADER} Roap OK`,
+              }
+            );
+            break;
 
-      switch (event.roapMessage.messageType) {
-        case 'OK':
-          logRequest(
-            this.roap.sendRoapOK({
-              seq: event.roapMessage.seq,
-              mediaId: this.mediaId,
-              correlationId: this.correlationId,
-            }),
-            {
-              logText: `${LOG_HEADER} Roap OK`,
-            }
-          );
-          break;
+          case 'OFFER':
+            logRequest(
+              this.roap
+                .sendRoapMediaRequest({
+                  sdp: event.roapMessage.sdp,
+                  seq: event.roapMessage.seq,
+                  tieBreaker: event.roapMessage.tieBreaker,
+                  meeting: this, // or can pass meeting ID
+                })
+                .then(({roapAnswer}) => {
+                  if (roapAnswer) {
+                    LoggerProxy.logger.log(`${LOG_HEADER} received Roap ANSWER in http response`);
+
+                    this.roapMessageReceived(roapAnswer);
+                  }
+                }),
+              {
+                logText: `${LOG_HEADER} Roap Offer`,
+              }
+            ).catch((error) => {
+              // @ts-ignore
+              this.webex.internal.newMetrics.submitClientEvent({
+                name: 'client.media-engine.remote-sdp-received',
+                payload: {
+                  canProceed: false,
+                  errors: [
+                    // @ts-ignore
+                    this.webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode(
+                      {
+                        clientErrorCode: CALL_DIAGNOSTIC_CONFIG.MISSING_ROAP_ANSWER_CLIENT_CODE,
+                      }
+                    ),
+                  ],
+                },
+                options: {meetingId: this.id, rawError: error},
+              });
+
+              this.deferSDPAnswer.reject(new Error('failed to send ROAP SDP offer'));
+              clearTimeout(this.sdpResponseTimer);
+              this.sdpResponseTimer = undefined;
+            });
+            break;
 
-        case 'OFFER':
-          logRequest(
-            this.roap
-              .sendRoapMediaRequest({
+          case 'ANSWER':
+            logRequest(
+              this.roap.sendRoapAnswer({
                 sdp: event.roapMessage.sdp,
                 seq: event.roapMessage.seq,
-                tieBreaker: event.roapMessage.tieBreaker,
-                meeting: this, // or can pass meeting ID
-              })
-              .then(({roapAnswer}) => {
-                if (roapAnswer) {
-                  LoggerProxy.logger.log(`${LOG_HEADER} received Roap ANSWER in http response`);
-
-                  this.roapMessageReceived(roapAnswer);
-                }
+                mediaId: this.mediaId,
+                correlationId: this.correlationId,
               }),
-            {
-              logText: `${LOG_HEADER} Roap Offer`,
-            }
-          ).catch(() => {
-            this.deferSDPAnswer.reject(new Error('failed to send ROAP SDP offer'));
-            clearTimeout(this.sdpResponseTimer);
-            this.sdpResponseTimer = undefined;
-          });
-          break;
-
-        case 'ANSWER':
-          logRequest(
-            this.roap.sendRoapAnswer({
-              sdp: event.roapMessage.sdp,
-              seq: event.roapMessage.seq,
-              mediaId: this.mediaId,
-              correlationId: this.correlationId,
-            }),
-            {
-              logText: `${LOG_HEADER} Roap Answer`,
-            }
-          ).catch((error) => {
-            const metricName = BEHAVIORAL_METRICS.ROAP_ANSWER_FAILURE;
-            const data = {
-              correlation_id: this.correlationId,
-              locus_id: this.locusUrl.split('/').pop(),
-              reason: error.message,
-              stack: error.stack,
-            };
-            const metadata = {
-              type: error.name,
-            };
-
-            Metrics.sendBehavioralMetric(metricName, data, metadata);
-          });
-          break;
+              {
+                logText: `${LOG_HEADER} Roap Answer`,
+              }
+            ).catch((error) => {
+              const metricName = BEHAVIORAL_METRICS.ROAP_ANSWER_FAILURE;
+              const data = {
+                correlation_id: this.correlationId,
+                locus_id: this.locusUrl.split('/').pop(),
+                reason: error.message,
+                stack: error.stack,
+              };
+              const metadata = {
+                type: error.name,
+              };
 
-        case 'ERROR':
-          if (
-            event.roapMessage.errorType === ErrorType.CONFLICT ||
-            event.roapMessage.errorType === ErrorType.DOUBLECONFLICT
-          ) {
-            Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_GLARE_CONDITION, {
-              correlation_id: this.correlationId,
-              locus_id: this.locusUrl.split('/').pop(),
-              sequence: event.roapMessage.seq,
+              Metrics.sendBehavioralMetric(metricName, data, metadata);
             });
-          }
-          logRequest(
-            this.roap.sendRoapError({
-              seq: event.roapMessage.seq,
-              errorType: event.roapMessage.errorType,
-              mediaId: this.mediaId,
-              correlationId: this.correlationId,
-            }),
-            {
-              logText: `${LOG_HEADER} Roap Error (${event.roapMessage.errorType})`,
+            break;
+
+          case 'ERROR':
+            if (
+              event.roapMessage.errorType === ErrorType.CONFLICT ||
+              event.roapMessage.errorType === ErrorType.DOUBLECONFLICT
+            ) {
+              Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_GLARE_CONDITION, {
+                correlation_id: this.correlationId,
+                locus_id: this.locusUrl.split('/').pop(),
+                sequence: event.roapMessage.seq,
+              });
             }
-          );
-          break;
+            logRequest(
+              this.roap.sendRoapError({
+                seq: event.roapMessage.seq,
+                errorType: event.roapMessage.errorType,
+                mediaId: this.mediaId,
+                correlationId: this.correlationId,
+              }),
+              {
+                logText: `${LOG_HEADER} Roap Error (${event.roapMessage.errorType})`,
+              }
+            );
+            break;
 
-        default:
-          LoggerProxy.logger.error(
-            `${LOG_HEADER} Unsupported message type: ${event.roapMessage.messageType}`
-          );
-          break;
+          default:
+            LoggerProxy.logger.error(
+              `${LOG_HEADER} Unsupported message type: ${event.roapMessage.messageType}`
+            );
+            break;
+        }
       }
-    });
+    );
 
     // eslint-disable-next-line no-param-reassign
-    this.mediaProperties.webrtcMediaConnection.on(Event.REMOTE_TRACK_ADDED, (event) => {
-      LoggerProxy.logger.log(
-        `Meeting:index#setupMediaConnectionListeners --> REMOTE_TRACK_ADDED event received for webrtcMediaConnection: ${JSON.stringify(
-          event
-        )}`
-      );
-
-      if (event.track) {
-        const mediaTrack = event.track;
-        const remoteStream = new RemoteStream(MediaUtil.createMediaStream([mediaTrack]));
+    this.mediaProperties.webrtcMediaConnection.on(
+      MediaConnectionEventNames.REMOTE_TRACK_ADDED,
+      (event) => {
+        LoggerProxy.logger.log(
+          `Meeting:index#setupMediaConnectionListeners --> REMOTE_TRACK_ADDED event received for webrtcMediaConnection: ${JSON.stringify(
+            event
+          )}`
+        );
 
-        // eslint-disable-next-line @typescript-eslint/no-shadow
-        let eventType;
+        if (event.track) {
+          const mediaTrack = event.track;
+          const remoteStream = new RemoteStream(MediaUtil.createMediaStream([mediaTrack]));
+
+          // eslint-disable-next-line @typescript-eslint/no-shadow
+          let eventType;
+
+          switch (event.type) {
+            case RemoteTrackType.AUDIO:
+              eventType = EVENT_TYPES.REMOTE_AUDIO;
+              this.mediaProperties.setRemoteAudioStream(remoteStream);
+              break;
+            case RemoteTrackType.VIDEO:
+              eventType = EVENT_TYPES.REMOTE_VIDEO;
+              this.mediaProperties.setRemoteVideoStream(remoteStream);
+              break;
+            case RemoteTrackType.SCREENSHARE_VIDEO:
+              eventType = EVENT_TYPES.REMOTE_SHARE;
+              this.mediaProperties.setRemoteShareStream(remoteStream);
+              break;
+            default: {
+              LoggerProxy.logger.log(
+                'Meeting:index#setupMediaConnectionListeners --> unexpected track'
+              );
+            }
+          }
 
-        switch (event.type) {
-          case RemoteTrackType.AUDIO:
-            eventType = EVENT_TYPES.REMOTE_AUDIO;
-            this.mediaProperties.setRemoteAudioStream(remoteStream);
-            break;
-          case RemoteTrackType.VIDEO:
-            eventType = EVENT_TYPES.REMOTE_VIDEO;
-            this.mediaProperties.setRemoteVideoStream(remoteStream);
-            break;
-          case RemoteTrackType.SCREENSHARE_VIDEO:
-            eventType = EVENT_TYPES.REMOTE_SHARE;
-            this.mediaProperties.setRemoteShareStream(remoteStream);
-            break;
-          default: {
-            LoggerProxy.logger.log(
-              'Meeting:index#setupMediaConnectionListeners --> unexpected track'
+          if (eventType && mediaTrack) {
+            Trigger.trigger(
+              this,
+              {
+                file: 'meeting/index',
+                function: 'setupRemoteTrackListener:MediaConnectionEventNames.REMOTE_TRACK_ADDED',
+              },
+              EVENT_TRIGGERS.MEDIA_READY,
+              {
+                type: eventType,
+                stream: remoteStream.outputStream,
+              }
             );
           }
         }
-
-        if (eventType && mediaTrack) {
-          Trigger.trigger(
-            this,
-            {
-              file: 'meeting/index',
-              function: 'setupRemoteTrackListener:Event.REMOTE_TRACK_ADDED',
-            },
-            EVENT_TRIGGERS.MEDIA_READY,
-            {
-              type: eventType,
-              stream: remoteStream.outputStream,
-            }
-          );
-        }
       }
-    });
+    );
+
+    this.connectionStateHandler = new ConnectionStateHandler(
+      this.mediaProperties.webrtcMediaConnection
+    );
 
-    this.mediaProperties.webrtcMediaConnection.on(Event.CONNECTION_STATE_CHANGED, (event) => {
+    this.connectionStateHandler.on(ConnectionStateEvent.stateChanged, (event) => {
       const connectionFailed = () => {
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.CONNECTION_FAILURE, {
           correlation_id: this.correlationId,
@@ -5875,7 +6006,6 @@ export default class Meeting extends StatelessWebexPlugin {
 
       // @ts-ignore
       const cdl = this.webex.internal.newMetrics.callDiagnosticLatencies;
-
       switch (event.state) {
         case ConnectionState.Connecting:
           if (!this.hasMediaConnectionConnectedAtLeastOnce) {
@@ -5932,25 +6062,28 @@ export default class Meeting extends StatelessWebexPlugin {
       }
     });
 
-    this.mediaProperties.webrtcMediaConnection.on(Event.ACTIVE_SPEAKERS_CHANGED, (csis) => {
-      Trigger.trigger(
-        this,
-        {
-          file: 'meeting/index',
-          function: 'setupMediaConnectionListeners',
-        },
-        EVENT_TRIGGERS.ACTIVE_SPEAKER_CHANGED,
-        {
-          memberIds: csis
-            // @ts-ignore
-            .map((csi) => this.members.findMemberByCsi(csi)?.id)
-            .filter((item) => item !== undefined),
-        }
-      );
-    });
+    this.mediaProperties.webrtcMediaConnection.on(
+      MediaConnectionEventNames.ACTIVE_SPEAKERS_CHANGED,
+      (csis) => {
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'setupMediaConnectionListeners',
+          },
+          EVENT_TRIGGERS.ACTIVE_SPEAKER_CHANGED,
+          {
+            memberIds: csis
+              // @ts-ignore
+              .map((csi) => this.members.findMemberByCsi(csi)?.id)
+              .filter((item) => item !== undefined),
+          }
+        );
+      }
+    );
 
     this.mediaProperties.webrtcMediaConnection.on(
-      Event.VIDEO_SOURCES_COUNT_CHANGED,
+      MediaConnectionEventNames.VIDEO_SOURCES_COUNT_CHANGED,
       (numTotalSources, numLiveSources, mediaContent) => {
         Trigger.trigger(
           this,
@@ -5973,7 +6106,7 @@ export default class Meeting extends StatelessWebexPlugin {
     );
 
     this.mediaProperties.webrtcMediaConnection.on(
-      Event.AUDIO_SOURCES_COUNT_CHANGED,
+      MediaConnectionEventNames.AUDIO_SOURCES_COUNT_CHANGED,
       (numTotalSources, numLiveSources, mediaContent) => {
         Trigger.trigger(
           this,
@@ -5990,6 +6123,45 @@ export default class Meeting extends StatelessWebexPlugin {
         );
       }
     );
+
+    this.iceCandidateErrors.clear();
+    this.mediaProperties.webrtcMediaConnection.on(
+      MediaConnectionEventNames.ICE_CANDIDATE_ERROR,
+      (event) => {
+        const {errorCode} = event.error;
+        let {errorText} = event.error;
+
+        if (
+          errorCode === 600 &&
+          errorText === 'Address not associated with the desired network interface.'
+        ) {
+          return;
+        }
+
+        if (errorText.endsWith('.')) {
+          errorText = errorText.slice(0, -1);
+        }
+
+        errorText = errorText.toLowerCase();
+        errorText = errorText.replace(/ /g, '_');
+
+        const error = `${errorCode}_${errorText}`;
+
+        const count = this.iceCandidateErrors.get(error) || 0;
+
+        this.iceCandidateErrors.set(error, count + 1);
+      }
+    );
+
+    this.iceCandidatesCount = 0;
+    this.mediaProperties.webrtcMediaConnection.on(
+      MediaConnectionEventNames.ICE_CANDIDATE,
+      (event) => {
+        if (event.candidate) {
+          this.iceCandidatesCount += 1;
+        }
+      }
+    );
   };
 
   /**
@@ -5999,7 +6171,7 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meetings
    */
   setupStatsAnalyzerEventHandlers = () => {
-    this.statsAnalyzer.on(StatsAnalyzerEvents.MEDIA_QUALITY, (options) => {
+    this.statsAnalyzer.on(StatsAnalyzerEventNames.MEDIA_QUALITY, (options) => {
       // TODO:  might have to send the same event to the developer
       // Add ip address info if geo hint is present
       // @ts-ignore fix type
@@ -6013,14 +6185,15 @@ export default class Meeting extends StatelessWebexPlugin {
         name: 'client.mediaquality.event',
         options: {
           meetingId: this.id,
-          networkType: options.networkType,
+          networkType: options.data.networkType,
         },
         payload: {
           intervals: [options.data],
         },
       });
     });
-    this.statsAnalyzer.on(StatsAnalyzerEvents.LOCAL_MEDIA_STARTED, (data) => {
+
+    this.statsAnalyzer.on(StatsAnalyzerEventNames.LOCAL_MEDIA_STARTED, (data) => {
       Trigger.trigger(
         this,
         {
@@ -6034,28 +6207,28 @@ export default class Meeting extends StatelessWebexPlugin {
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.media.tx.start',
         payload: {
-          mediaType: data.type,
-          shareInstanceId: data.type === 'share' ? this.localShareInstanceId : undefined,
+          mediaType: data.mediaType,
+          shareInstanceId: data.mediaType === 'share' ? this.localShareInstanceId : undefined,
         },
         options: {
           meetingId: this.id,
         },
       });
     });
-    this.statsAnalyzer.on(StatsAnalyzerEvents.LOCAL_MEDIA_STOPPED, (data) => {
+    this.statsAnalyzer.on(StatsAnalyzerEventNames.LOCAL_MEDIA_STOPPED, (data) => {
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.media.tx.stop',
         payload: {
-          mediaType: data.type,
-          shareInstanceId: data.type === 'share' ? this.localShareInstanceId : undefined,
+          mediaType: data.mediaType,
+          shareInstanceId: data.mediaType === 'share' ? this.localShareInstanceId : undefined,
         },
         options: {
           meetingId: this.id,
         },
       });
     });
-    this.statsAnalyzer.on(StatsAnalyzerEvents.REMOTE_MEDIA_STARTED, (data) => {
+    this.statsAnalyzer.on(StatsAnalyzerEventNames.REMOTE_MEDIA_STARTED, (data) => {
       Trigger.trigger(
         this,
         {
@@ -6069,15 +6242,15 @@ export default class Meeting extends StatelessWebexPlugin {
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.media.rx.start',
         payload: {
-          mediaType: data.type,
-          shareInstanceId: data.type === 'share' ? this.remoteShareInstanceId : undefined,
+          mediaType: data.mediaType,
+          shareInstanceId: data.mediaType === 'share' ? this.remoteShareInstanceId : undefined,
         },
         options: {
           meetingId: this.id,
         },
       });
 
-      if (data.type === 'share') {
+      if (data.mediaType === 'share') {
         // @ts-ignore
         this.webex.internal.newMetrics.submitClientEvent({
           name: 'client.media.render.start',
@@ -6091,20 +6264,20 @@ export default class Meeting extends StatelessWebexPlugin {
         });
       }
     });
-    this.statsAnalyzer.on(StatsAnalyzerEvents.REMOTE_MEDIA_STOPPED, (data) => {
+    this.statsAnalyzer.on(StatsAnalyzerEventNames.REMOTE_MEDIA_STOPPED, (data) => {
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.media.rx.stop',
         payload: {
-          mediaType: data.type,
-          shareInstanceId: data.type === 'share' ? this.remoteShareInstanceId : undefined,
+          mediaType: data.mediaType,
+          shareInstanceId: data.mediaType === 'share' ? this.remoteShareInstanceId : undefined,
         },
         options: {
           meetingId: this.id,
         },
       });
 
-      if (data.type === 'share') {
+      if (data.mediaType === 'share') {
         // @ts-ignore
         this.webex.internal.newMetrics.submitClientEvent({
           name: 'client.media.render.stop',
@@ -6264,6 +6437,8 @@ export default class Meeting extends StatelessWebexPlugin {
     try {
       await this.mediaProperties.waitForMediaConnectionConnected();
     } catch (error) {
+      const {iceConnected} = error;
+
       if (!this.hasMediaConnectionConnectedAtLeastOnce) {
         // Only send CA event for join flow if we haven't successfully connected media yet
         // @ts-ignore
@@ -6271,7 +6446,7 @@ export default class Meeting extends StatelessWebexPlugin {
           name: 'client.ice.end',
           payload: {
             canProceed: !this.turnServerUsed, // If we haven't done turn tls retry yet we will proceed with join attempt
-            icePhase: this.turnServerUsed ? 'JOIN_MEETING_FINAL' : 'JOIN_MEETING_RETRY',
+            icePhase: this.addMediaData.icePhaseCallback(),
             errors: [
               // @ts-ignore
               this.webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode(
@@ -6283,13 +6458,13 @@ export default class Meeting extends StatelessWebexPlugin {
                       this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc
                         ?.signalingState ||
                       'unknown',
-                    iceConnectionState:
-                      this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
-                        ?.iceConnectionState ||
-                      this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc
-                        ?.iceConnectionState ||
-                      'unknown',
+                    iceConnected,
                     turnServerUsed: this.turnServerUsed,
+                    unreachable:
+                      // @ts-ignore
+                      await this.webex.meetings.reachability
+                        .isWebexMediaBackendUnreachable()
+                        .catch(() => false),
                   }),
                 }
               ),
@@ -6317,12 +6492,12 @@ export default class Meeting extends StatelessWebexPlugin {
     if (this.config.stats.enableStatsAnalyzer) {
       // @ts-ignore - config coming from registerPlugin
       this.networkQualityMonitor = new NetworkQualityMonitor(this.config.stats);
-      this.statsAnalyzer = new StatsAnalyzer(
+      this.statsAnalyzer = new StatsAnalyzer({
         // @ts-ignore - config coming from registerPlugin
-        this.config.stats,
-        (ssrc: number) => this.receiveSlotManager.findReceiveSlotBySsrc(ssrc),
-        this.networkQualityMonitor
-      );
+        config: this.config.stats,
+        networkQualityMonitor: this.networkQualityMonitor,
+        isMultistream: this.isMultistream,
+      });
       this.setupStatsAnalyzerEventHandlers();
       this.networkQualityMonitor.on(
         EVENT_TRIGGERS.NETWORK_QUALITY,
@@ -6374,6 +6549,21 @@ export default class Meeting extends StatelessWebexPlugin {
           ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT / 1000
         } seconds`
       );
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.media-engine.remote-sdp-received',
+        payload: {
+          canProceed: false,
+          errors: [
+            // @ts-ignore
+            this.webex.internal.newMetrics.callDiagnosticMetrics.getErrorPayloadForClientErrorCode({
+              clientErrorCode: CALL_DIAGNOSTIC_CONFIG.MISSING_ROAP_ANSWER_CLIENT_CODE,
+            }),
+          ],
+        },
+        options: {meetingId: this.id, rawError: new Error('Timeout waiting for SDP answer')},
+      });
+
       deferSDPAnswer.reject(new Error('Timed out waiting for REMOTE SDP ANSWER'));
     }, ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT);
 
@@ -6422,7 +6612,7 @@ export default class Meeting extends StatelessWebexPlugin {
     remoteMediaManagerConfig?: RemoteMediaManagerConfiguration,
     bundlePolicy?: BundlePolicy
   ): Promise<void> {
-    this.retriedWithTurnServer = true;
+    this.addMediaData.retriedWithTurnServer = true;
     const LOG_HEADER = 'Meeting:index#addMedia():retryWithForcedTurnDiscovery -->';
 
     await this.cleanUpBeforeRetryWithTurnServer();
@@ -6517,7 +6707,7 @@ export default class Meeting extends StatelessWebexPlugin {
         correlation_id: this.correlationId,
         latency: cdl.getTurnDiscoveryTime(),
         turnServerUsed: this.turnServerUsed,
-        retriedWithTurnServer: this.retriedWithTurnServer,
+        retriedWithTurnServer: this.addMediaData.retriedWithTurnServer,
       });
     }
 
@@ -6541,7 +6731,8 @@ export default class Meeting extends StatelessWebexPlugin {
     turnServerInfo?: TurnServerInfo
   ): Promise<void> {
     const LOG_HEADER = 'Meeting:index#addMedia():establishMediaConnection -->';
-    const isReconnecting = this.isMoveToInProgress || this.retriedWithTurnServer;
+    const isReconnecting =
+      this.isMoveToInProgress || !!this.locusMediaRequest?.isConfluenceCreated();
 
     // We are forcing turn discovery if the case is moveTo and a turn server was used already
     if (this.isMoveToInProgress && this.turnServerUsed) {
@@ -6663,24 +6854,80 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   }
 
+  /**
+   * Creates an instance of LocusMediaRequest for this meeting - it is needed for doing any calls
+   * to Locus /media API (these are used for sending Roap messages and updating audio/video mute status).
+   *
+   * @returns {void}
+   */
+  private setupLocusMediaRequest() {
+    this.locusMediaRequest = new LocusMediaRequest(
+      {
+        correlationId: this.correlationId,
+        meetingId: this.id,
+        device: {
+          url: this.deviceUrl,
+          // @ts-ignore
+          deviceType: this.config.deviceType,
+          // @ts-ignore
+          countryCode: this.webex.meetings.geoHintInfo?.countryCode,
+          // @ts-ignore
+          regionCode: this.webex.meetings.geoHintInfo?.regionCode,
+        },
+        preferTranscoding: !this.isMultistream,
+      },
+      {
+        // @ts-ignore
+        parent: this.webex,
+      }
+    );
+  }
+
   /**
    * 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 = {},
-    turnServerInfo: TurnServerInfo = undefined
+  addMedia(options: AddMediaOptions = {}): Promise<void> {
+    return this.addMediaInternal(
+      () => (this.turnServerUsed ? 'JOIN_MEETING_FINAL' : 'JOIN_MEETING_RETRY'),
+      undefined,
+      false,
+      options
+    );
+  }
+
+  /**
+   * Internal version of addMedia() with some more arguments for finer control of its behavior
+   *
+   * @param {Function} icePhaseCallback - callback to determine the icePhase for CA "client.ice.end" failure events
+   * @param {TurnServerInfo} turnServerInfo - TURN server information
+   * @param {boolean} forceTurnDiscovery - if true, TURN discovery will be done
+   * @param {AddMediaOptions} options - same as options of the public addMedia() method
+   * @returns {Promise<void>}
+   * @protected
+   * @memberof Meeting
+   */
+  protected async addMediaInternal(
+    icePhaseCallback: () => string,
+    turnServerInfo: TurnServerInfo,
+    forceTurnDiscovery,
+    options: AddMediaOptions = {}
   ): Promise<void> {
-    this.retriedWithTurnServer = false;
+    this.addMediaData.retriedWithTurnServer = false;
+    this.addMediaData.icePhaseCallback = icePhaseCallback;
+
     this.hasMediaConnectionConnectedAtLeastOnce = false;
     const LOG_HEADER = 'Meeting:index#addMedia -->';
     LoggerProxy.logger.info(
-      `${LOG_HEADER} called with: ${JSON.stringify(options)}, ${JSON.stringify(turnServerInfo)}`
+      `${LOG_HEADER} called with: options=${JSON.stringify(
+        options
+      )}, turnServerInfo=${JSON.stringify(
+        turnServerInfo
+      )}, forceTurnDiscovery=${forceTurnDiscovery}`
     );
 
     if (options.allowMediaInLobby !== true && this.meetingState !== FULL_STATE.ACTIVE) {
@@ -6744,27 +6991,6 @@ export default class Meeting extends StatelessWebexPlugin {
       receiveShare: shareAudioEnabled || shareVideoEnabled,
     });
 
-    this.locusMediaRequest = new LocusMediaRequest(
-      {
-        correlationId: this.correlationId,
-        meetingId: this.id,
-        device: {
-          url: this.deviceUrl,
-          // @ts-ignore
-          deviceType: this.config.deviceType,
-          // @ts-ignore
-          countryCode: this.webex.meetings.geoHintInfo?.countryCode,
-          // @ts-ignore
-          regionCode: this.webex.meetings.geoHintInfo?.regionCode,
-        },
-        preferTranscoding: !this.isMultistream,
-      },
-      {
-        // @ts-ignore
-        parent: this.webex,
-      }
-    );
-
     this.audio = createMuteState(AUDIO, this, audioEnabled);
     this.video = createMuteState(VIDEO, this, videoEnabled);
 
@@ -6778,7 +7004,7 @@ export default class Meeting extends StatelessWebexPlugin {
       await this.establishMediaConnection(
         remoteMediaManagerConfig,
         bundlePolicy,
-        false,
+        forceTurnDiscovery,
         turnServerInfo
       );
 
@@ -6804,9 +7030,10 @@ export default class Meeting extends StatelessWebexPlugin {
         selectedCandidatePairChanges,
         numTransports,
         isMultistream: this.isMultistream,
-        retriedWithTurnServer: this.retriedWithTurnServer,
+        retriedWithTurnServer: this.addMediaData.retriedWithTurnServer,
         isJoinWithMediaRetry: this.joinWithMediaRetryInfo.isRetry,
         ...reachabilityStats,
+        iceCandidatesCount: this.iceCandidatesCount,
       });
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
@@ -6830,6 +7057,8 @@ export default class Meeting extends StatelessWebexPlugin {
       const {selectedCandidatePairChanges, numTransports} =
         await this.mediaProperties.getCurrentConnectionInfo();
 
+      const iceCandidateErrors = Object.fromEntries(this.iceCandidateErrors);
+
       Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
         correlation_id: this.correlationId,
         locus_id: this.locusUrl.split('/').pop(),
@@ -6840,7 +7069,7 @@ export default class Meeting extends StatelessWebexPlugin {
         numTransports,
         turnDiscoverySkippedReason: this.turnDiscoverySkippedReason,
         turnServerUsed: this.turnServerUsed,
-        retriedWithTurnServer: this.retriedWithTurnServer,
+        retriedWithTurnServer: this.addMediaData.retriedWithTurnServer,
         isMultistream: this.isMultistream,
         isJoinWithMediaRetry: this.joinWithMediaRetryInfo.isRetry,
         signalingState:
@@ -6859,6 +7088,8 @@ export default class Meeting extends StatelessWebexPlugin {
           this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.iceConnectionState ||
           'unknown',
         ...reachabilityMetrics,
+        ...iceCandidateErrors,
+        iceCandidatesCount: this.iceCandidatesCount,
       });
 
       await this.cleanUpOnAddMediaFailure();
@@ -6879,6 +7110,8 @@ export default class Meeting extends StatelessWebexPlugin {
       }
 
       throw error;
+    } finally {
+      this.addMediaData.icePhaseCallback = DEFAULT_ICE_PHASE_CALLBACK;
     }
   }
 
@@ -7896,6 +8129,7 @@ export default class Meeting extends StatelessWebexPlugin {
     Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_SHARE_VIDEO_MUTE_STATE_CHANGE, {
       correlationId: this.correlationId,
       muted,
+      encoderImplementation: this.statsAnalyzer?.shareVideoEncoderImplementation,
     });
   };