@webex/plugin-meetings 3.3.1-next.39 → 3.3.1-next.40

package/src/meeting/index.ts

@@ -17,11 +17,13 @@ import {
   ConnectionState,
   Errors,
   ErrorType,
-  Event,
+  MediaConnectionEventNames,
   MediaContent,
   MediaType,
   RemoteTrackType,
   RoapMessage,
+  StatsAnalyzer,
+  StatsAnalyzerEventNames,
 } from '@webex/internal-media-core';
 
 import {
@@ -41,6 +43,7 @@ import {
   TURN_ON_CAPTION_STATUS,
   type MeetingTranscriptPayload,
 } from '@webex/internal-plugin-voicea';
+
 import {processNewCaptions} from './voicea-meeting';
 
 import {
@@ -51,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';
@@ -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';
@@ -5726,234 +5726,252 @@ 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(Event.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;
+    this.mediaProperties.webrtcMediaConnection.on(
+      MediaConnectionEventNames.ROAP_FAILURE,
+      this.handleRoapFailure
+    );
 
-        case 'OFFER':
-          logRequest(
-            this.roap
-              .sendRoapMediaRequest({
-                sdp: event.roapMessage.sdp,
+    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,
-                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((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},
-            });
+              {
+                logText: `${LOG_HEADER} Roap OK`,
+              }
+            );
+            break;
 
-            this.deferSDPAnswer.reject(new Error('failed to send ROAP SDP offer'));
-            clearTimeout(this.sdpResponseTimer);
-            this.sdpResponseTimer = undefined;
-          });
-          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},
+              });
 
-        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,
-            };
+              this.deferSDPAnswer.reject(new Error('failed to send ROAP SDP offer'));
+              clearTimeout(this.sdpResponseTimer);
+              this.sdpResponseTimer = undefined;
+            });
+            break;
 
-            Metrics.sendBehavioralMetric(metricName, data, metadata);
-          });
-          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,
+              };
 
-        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
@@ -5988,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) {
@@ -6045,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,
@@ -6086,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,
@@ -6105,37 +6125,43 @@ export default class Meeting extends StatelessWebexPlugin {
     );
 
     this.iceCandidateErrors.clear();
-    this.mediaProperties.webrtcMediaConnection.on(Event.ICE_CANDIDATE_ERROR, (event) => {
-      const {errorCode} = event.error;
-      let {errorText} = event.error;
+    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 (
+          errorCode === 600 &&
+          errorText === 'Address not associated with the desired network interface.'
+        ) {
+          return;
+        }
 
-      if (errorText.endsWith('.')) {
-        errorText = errorText.slice(0, -1);
-      }
+        if (errorText.endsWith('.')) {
+          errorText = errorText.slice(0, -1);
+        }
 
-      errorText = errorText.toLowerCase();
-      errorText = errorText.replace(/ /g, '_');
+        errorText = errorText.toLowerCase();
+        errorText = errorText.replace(/ /g, '_');
 
-      const error = `${errorCode}_${errorText}`;
+        const error = `${errorCode}_${errorText}`;
 
-      const count = this.iceCandidateErrors.get(error) || 0;
+        const count = this.iceCandidateErrors.get(error) || 0;
 
-      this.iceCandidateErrors.set(error, count + 1);
-    });
+        this.iceCandidateErrors.set(error, count + 1);
+      }
+    );
 
     this.iceCandidatesCount = 0;
-    this.mediaProperties.webrtcMediaConnection.on(Event.ICE_CANDIDATE, (event) => {
-      if (event.candidate) {
-        this.iceCandidatesCount += 1;
+    this.mediaProperties.webrtcMediaConnection.on(
+      MediaConnectionEventNames.ICE_CANDIDATE,
+      (event) => {
+        if (event.candidate) {
+          this.iceCandidatesCount += 1;
+        }
       }
-    });
+    );
   };
 
   /**
@@ -6145,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
@@ -6159,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,
         {
@@ -6180,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,
         {
@@ -6215,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',
@@ -6237,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',
@@ -6468,7 +6495,6 @@ export default class Meeting extends StatelessWebexPlugin {
       this.statsAnalyzer = new StatsAnalyzer({
         // @ts-ignore - config coming from registerPlugin
         config: this.config.stats,
-        receiveSlotCallback: (ssrc: number) => this.receiveSlotManager.findReceiveSlotBySsrc(ssrc),
         networkQualityMonitor: this.networkQualityMonitor,
         isMultistream: this.isMultistream,
       });