@webex/plugin-meetings 3.0.0-beta.2 → 3.0.0-beta.20

package/src/statsAnalyzer/{index.js → index.ts}

@@ -1,8 +1,17 @@
+/* eslint-disable prefer-destructuring */
+
 import {cloneDeep} from 'lodash';
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {ConnectionState} from '@webex/internal-media-core';
 
 import EventsScope from '../common/events/events-scope';
-import {DEFAULT_GET_STATS_FILTER, STATS, MQA_INTEVAL, NETWORK_TYPE, MEDIA_DEVICES, _UNKNOWN_} from '../constants';
+import {
+  DEFAULT_GET_STATS_FILTER,
+  STATS,
+  MQA_INTEVAL,
+  NETWORK_TYPE,
+  MEDIA_DEVICES,
+  _UNKNOWN_,
+} from '../constants';
 import mqaData from '../mediaQualityMetrics/config';
 import LoggerProxy from '../common/logs/logger-proxy';
 
@@ -11,7 +20,7 @@ import {
   getAudioSenderMqa,
   getAudioReceiverMqa,
   getVideoSenderMqa,
-  getVideoReceiverMqa
+  getVideoReceiverMqa,
 } from './mqaUtil';
 
 export const EVENTS = {
@@ -30,6 +39,21 @@ export const EVENTS = {
  * @extends {EventsScope}
  */
 export class StatsAnalyzer extends EventsScope {
+  config: any;
+  correlationId: any;
+  lastEmittedStartStopEvent: any;
+  lastMqaDataSent: any;
+  lastStatsResults: any;
+  localMQEStats: any;
+  meetingMediaStatus: any;
+  mqaInterval: NodeJS.Timeout;
+  mqaSentCount: any;
+  networkQualityMonitor: any;
+  mediaConnection: any;
+  statsInterval: NodeJS.Timeout;
+  statsResults: any;
+  statsStarted: any;
+
   /**
    * Creates a new instance of StatsAnalyzer
    * @constructor
@@ -38,7 +62,11 @@ export class StatsAnalyzer extends EventsScope {
    * @param {Object} networkQualityMonitor class for assessing network characteristics (jitter, packetLoss, latency)
    * @param {Object} statsResults Default properties for stats
    */
-  constructor(config, networkQualityMonitor = {}, statsResults = defaultStats) {
+  constructor(
+    config: any,
+    networkQualityMonitor: object = {},
+    statsResults: object = defaultStats
+  ) {
     super();
     this.statsStarted = false;
     this.statsResults = statsResults;
@@ -48,10 +76,14 @@ export class StatsAnalyzer extends EventsScope {
     this.correlationId = config.correlationId;
     this.mqaSentCount = -1;
     this.lastMqaDataSent = {
-      resolutions: {video: {send: {}, recv: {}}, audio: {send: {}, recv: {}}, share: {send: {}, recv: {}}},
+      resolutions: {
+        video: {send: {}, recv: {}},
+        audio: {send: {}, recv: {}},
+        share: {send: {}, recv: {}},
+      },
       video: {send: {}, recv: {}},
       audio: {send: {}, recv: {}},
-      share: {send: {}, recv: {}}
+      share: {send: {}, recv: {}},
     };
     this.localMQEStats = {
       audio: {
@@ -59,14 +91,14 @@ export class StatsAnalyzer extends EventsScope {
           packetsLost: [],
           jitter: [],
           latency: [],
-          bitRate: []
+          bitRate: [],
         },
         TX: {
           packetsLost: [],
           jitter: [],
           latency: [],
-          bitRate: []
-        }
+          bitRate: [],
+        },
       },
       video: {
         RX: {
@@ -78,7 +110,7 @@ export class StatsAnalyzer extends EventsScope {
           resolutionWidth: [],
           resolutionHeight: [],
           requestedKeyFrame: [],
-          receivedKeyFrame: []
+          receivedKeyFrame: [],
         },
         TX: {
           packetsLost: [],
@@ -89,9 +121,9 @@ export class StatsAnalyzer extends EventsScope {
           resolutionWidth: [],
           resolutionHeight: [],
           requestedKeyFrame: [],
-          receivedKeyFrame: []
-        }
-      }
+          receivedKeyFrame: [],
+        },
+      },
     };
     this.lastEmittedStartStopEvent = {
       audio: {
@@ -115,37 +147,60 @@ export class StatsAnalyzer extends EventsScope {
     this.localMQEStats.audio.RX.packetsLost.push(lastMqa.audioReceive[0].common.mediaHopByHopLost);
     this.localMQEStats.audio.RX.jitter.push(lastMqa.audioReceive[0].streams[0].common.rtpJitter);
     this.localMQEStats.audio.RX.latency.push(lastMqa.audioReceive[0].common.roundTripTime);
-    this.localMQEStats.audio.RX.bitRate.push(lastMqa.audioReceive[0].streams[0].common.receivedBitrate);
+    this.localMQEStats.audio.RX.bitRate.push(
+      lastMqa.audioReceive[0].streams[0].common.receivedBitrate
+    );
 
     this.localMQEStats.audio.TX.packetsLost.push(lastMqa.audioTransmit[0].common.remoteLossRate);
     this.localMQEStats.audio.TX.jitter.push(lastMqa.audioTransmit[0].common.remoteJitter);
     this.localMQEStats.audio.TX.latency.push(lastMqa.audioTransmit[0].common.roundTripTime);
-    this.localMQEStats.audio.TX.bitRate.push(lastMqa.audioTransmit[0].streams[0].common.transmittedBitrate);
+    this.localMQEStats.audio.TX.bitRate.push(
+      lastMqa.audioTransmit[0].streams[0].common.transmittedBitrate
+    );
 
     // Video
 
     this.localMQEStats.video.RX.packetsLost.push(lastMqa.videoReceive[0].common.mediaHopByHopLost);
     this.localMQEStats.video.RX.jitter.push(lastMqa.videoReceive[0].streams[0].common.rtpJitter);
-    this.localMQEStats.video.RX.latency.push(lastMqa.videoReceive[0].streams[0].common.roundTripTime);
-    this.localMQEStats.video.RX.bitRate.push(lastMqa.videoReceive[0].streams[0].common.receivedBitrate);
-    this.localMQEStats.video.RX.frameRate.push(lastMqa.videoReceive[0].streams[0].common.receivedFrameRate);
-    this.localMQEStats.video.RX.resolutionWidth.push(lastMqa.videoReceive[0].streams[0].receivedWidth);
-    this.localMQEStats.video.RX.resolutionHeight.push(lastMqa.videoReceive[0].streams[0].receivedHeight);
+    this.localMQEStats.video.RX.latency.push(
+      lastMqa.videoReceive[0].streams[0].common.roundTripTime
+    );
+    this.localMQEStats.video.RX.bitRate.push(
+      lastMqa.videoReceive[0].streams[0].common.receivedBitrate
+    );
+    this.localMQEStats.video.RX.frameRate.push(
+      lastMqa.videoReceive[0].streams[0].common.receivedFrameRate
+    );
+    this.localMQEStats.video.RX.resolutionWidth.push(
+      lastMqa.videoReceive[0].streams[0].receivedWidth
+    );
+    this.localMQEStats.video.RX.resolutionHeight.push(
+      lastMqa.videoReceive[0].streams[0].receivedHeight
+    );
     this.localMQEStats.video.RX.requestedKeyFrame.push();
     this.localMQEStats.video.RX.receivedKeyFrame.push();
 
     this.localMQEStats.video.TX.packetsLost.push(lastMqa.videoTransmit[0].common.remoteLossRate);
     this.localMQEStats.video.TX.jitter.push(lastMqa.videoTransmit[0].common.remoteJitter);
     this.localMQEStats.video.TX.latency.push(lastMqa.videoTransmit[0].common.roundTripTime);
-    this.localMQEStats.video.TX.bitRate.push(lastMqa.videoTransmit[0].streams[0].common.transmittedBitrate);
-    this.localMQEStats.video.TX.frameRate.push(lastMqa.videoTransmit[0].streams[0].common.transmittedFrameRate);
-    this.localMQEStats.video.TX.resolutionWidth.push(lastMqa.videoTransmit[0].streams[0].transmittedWidth);
-    this.localMQEStats.video.TX.resolutionHeight.push(lastMqa.videoTransmit[0].streams[0].transmittedHeight);
-    this.localMQEStats.video.TX.requestedKeyFrame.push(lastMqa.videoTransmit[0].streams[0].requestedKeyFrames);
+    this.localMQEStats.video.TX.bitRate.push(
+      lastMqa.videoTransmit[0].streams[0].common.transmittedBitrate
+    );
+    this.localMQEStats.video.TX.frameRate.push(
+      lastMqa.videoTransmit[0].streams[0].common.transmittedFrameRate
+    );
+    this.localMQEStats.video.TX.resolutionWidth.push(
+      lastMqa.videoTransmit[0].streams[0].transmittedWidth
+    );
+    this.localMQEStats.video.TX.resolutionHeight.push(
+      lastMqa.videoTransmit[0].streams[0].transmittedHeight
+    );
+    this.localMQEStats.video.TX.requestedKeyFrame.push(
+      lastMqa.videoTransmit[0].streams[0].requestedKeyFrames
+    );
     this.localMQEStats.video.TX.receivedKeyFrame.push();
   }
 
-
   resetStatsResults() {
     this.statsResults.audio.send.meanRemoteJitter = [];
     this.statsResults.video.send.meanRemoteJitter = [];
@@ -171,7 +226,7 @@ export class StatsAnalyzer extends EventsScope {
    * @memberof StatsAnalyzer
    * @returns {void}
    */
-  updateMediaStatus(status) {
+  public updateMediaStatus(status: object) {
     this.meetingMediaStatus = status;
   }
 
@@ -182,7 +237,7 @@ export class StatsAnalyzer extends EventsScope {
    * @memberof StatsAnalyzer
    * @returns {void}
    */
-  sendMqaData() {
+  public sendMqaData() {
     const audioReceiver = mqaData.intervals[0].audioReceive[0];
     const audioSender = mqaData.intervals[0].audioTransmit[0];
     const videoReceiver = mqaData.intervals[0].videoReceive[0];
@@ -193,23 +248,23 @@ export class StatsAnalyzer extends EventsScope {
     getAudioSenderMqa({
       audioSender,
       statsResults: this.statsResults,
-      lastMqaDataSent: this.lastMqaDataSent
+      lastMqaDataSent: this.lastMqaDataSent,
     });
     getAudioReceiverMqa({
       audioReceiver,
       statsResults: this.statsResults,
-      lastMqaDataSent: this.lastMqaDataSent
+      lastMqaDataSent: this.lastMqaDataSent,
     });
 
     getVideoReceiverMqa({
       videoReceiver,
       statsResults: this.statsResults,
-      lastMqaDataSent: this.lastMqaDataSent
+      lastMqaDataSent: this.lastMqaDataSent,
     });
     getVideoSenderMqa({
       videoSender,
       statsResults: this.statsResults,
-      lastMqaDataSent: this.lastMqaDataSent
+      lastMqaDataSent: this.lastMqaDataSent,
     });
 
     // Capture mqa for share scenario
@@ -218,25 +273,36 @@ export class StatsAnalyzer extends EventsScope {
       videoSender: shareSender,
       statsResults: this.statsResults,
       lastMqaDataSent: this.lastMqaDataSent,
-      isShareStream: true
+      isShareStream: true,
     });
 
     getVideoReceiverMqa({
       videoReceiver: shareReceiver,
       statsResults: this.statsResults,
       lastMqaDataSent: this.lastMqaDataSent,
-      isShareStream: true
+      isShareStream: true,
     });
-
-    mqaData.intervals[0].intervalMetadata.peerReflexiveIP = this.statsResults.connectionType.local.ipAddress[0];
+    mqaData.intervals[0].intervalMetadata.peerReflexiveIP =
+      this.statsResults.connectionType.local.ipAddress[0];
 
     // Adding peripheral information
     mqaData.intervals[0].intervalMetadata.peripherals = [];
-    mqaData.intervals[0].intervalMetadata.peripherals.push({information: _UNKNOWN_, name: MEDIA_DEVICES.SPEAKER});
-    mqaData.intervals[0].intervalMetadata.peripherals.push({information: this.statsResults[STATS.AUDIO_CORRELATE][STATS.SEND_DIRECTION].trackLabel || _UNKNOWN_, name: MEDIA_DEVICES.MICROPHONE});
-    mqaData.intervals[0].intervalMetadata.peripherals.push({information: this.statsResults[STATS.VIDEO_CORRELATE][STATS.SEND_DIRECTION].trackLabel || _UNKNOWN_, name: MEDIA_DEVICES.CAMERA});
-
+    mqaData.intervals[0].intervalMetadata.peripherals.push({
+      information: _UNKNOWN_,
+      name: MEDIA_DEVICES.SPEAKER,
+    });
+    mqaData.intervals[0].intervalMetadata.peripherals.push({
+      information:
+        this.statsResults[STATS.AUDIO_CORRELATE][STATS.SEND_DIRECTION].trackLabel || _UNKNOWN_,
+      name: MEDIA_DEVICES.MICROPHONE,
+    });
+    mqaData.intervals[0].intervalMetadata.peripherals.push({
+      information:
+        this.statsResults[STATS.VIDEO_CORRELATE][STATS.SEND_DIRECTION].trackLabel || _UNKNOWN_,
+      name: MEDIA_DEVICES.CAMERA,
+    });
 
+    // @ts-ignore
     mqaData.networkType = this.statsResults.connectionType.local.networkType;
 
     this.mqaSentCount += 1;
@@ -253,12 +319,13 @@ export class StatsAnalyzer extends EventsScope {
     this.emit(
       {
         file: 'statsAnalyzer',
-        function: 'sendMqaData'
+        function: 'sendMqaData',
       },
       EVENTS.MEDIA_QUALITY,
       {
         data: mqaData.intervals[0],
-        networkType: mqaData.networkType
+        // @ts-ignore
+        networkType: mqaData.networkType,
       }
     );
   }
@@ -268,10 +335,10 @@ export class StatsAnalyzer extends EventsScope {
    *
    * @private
    * @memberof StatsAnalyzer
-   * @param {MC.RoapMediaConnection} mediaConnection
+   * @param {RoapMediaConnection} mediaConnection
    * @returns {void}
    */
-  updateMediaConnection(mediaConnection) {
+  updateMediaConnection(mediaConnection: any) {
     this.mediaConnection = mediaConnection;
   }
 
@@ -280,25 +347,24 @@ export class StatsAnalyzer extends EventsScope {
    *
    * @public
    * @memberof StatsAnalyzer
-   * @param {MC.RoapMediaConnection} mediaConnection
+   * @param {RoapMediaConnection} mediaConnection
    * @returns {Promise}
    */
-  startAnalyzer(mediaConnection) {
+  public startAnalyzer(mediaConnection: any) {
     if (!this.statsStarted) {
       this.statsStarted = true;
       this.mediaConnection = mediaConnection;
 
-      return this.getStatsAndParse()
-        .then(() => {
-          this.statsInterval = setInterval(() => {
-            this.getStatsAndParse();
-          }, this.config.analyzerInterval);
-          // Trigger initial fetch
+      return this.getStatsAndParse().then(() => {
+        this.statsInterval = setInterval(() => {
+          this.getStatsAndParse();
+        }, this.config.analyzerInterval);
+        // Trigger initial fetch
+        this.sendMqaData();
+        this.mqaInterval = setInterval(() => {
           this.sendMqaData();
-          this.mqaInterval = setInterval(() => {
-            this.sendMqaData();
-          }, MQA_INTEVAL);
-        });
+        }, MQA_INTEVAL);
+      });
     }
 
     return Promise.resolve();
@@ -311,7 +377,7 @@ export class StatsAnalyzer extends EventsScope {
    * @memberof StatsAnalyzer
    * @returns {void}
    */
-  stopAnalyzer() {
+  public stopAnalyzer() {
     const sendOneLastMqa = this.mqaInterval && this.statsInterval;
 
     if (this.statsInterval) {
@@ -345,7 +411,7 @@ export class StatsAnalyzer extends EventsScope {
    * @returns {void}
    * @memberof StatsAnalyzer
    */
-  parseGetStatsResult(getStatsResult, type, isSender) {
+  private parseGetStatsResult(getStatsResult: any, type: string, isSender: boolean) {
     if (!getStatsResult) {
       return;
     }
@@ -362,6 +428,7 @@ export class StatsAnalyzer extends EventsScope {
         break;
       case 'remote-inbound-rtp':
       case 'remote-outbound-rtp':
+        // @ts-ignore
         this.compareSentAndReceived(getStatsResult, type, isSender);
         break;
       case 'remotecandidate':
@@ -372,6 +439,7 @@ export class StatsAnalyzer extends EventsScope {
         this.parseCandidate(getStatsResult, type, isSender, false);
         break;
       case 'media-source':
+        // @ts-ignore
         this.parseAudioSource(getStatsResult, type);
         break;
       default:
@@ -387,7 +455,11 @@ export class StatsAnalyzer extends EventsScope {
    * @param {boolean} isSender
    * @returns {void}
    */
-  filterAndParseGetStatsResults(getStatsResults, type, isSender) {
+  private filterAndParseGetStatsResults(
+    getStatsResults: Array<any>,
+    type: string,
+    isSender: boolean
+  ) {
     const {types} = DEFAULT_GET_STATS_FILTER;
 
     getStatsResults.forEach((result) => {
@@ -403,7 +475,7 @@ export class StatsAnalyzer extends EventsScope {
    * @param {boolean} type
    * @returns {void}
    */
-  parseAudioSource(result, type) {
+  parseAudioSource(result: any, type: any) {
     if (!result) {
       return;
     }
@@ -428,7 +500,12 @@ export class StatsAnalyzer extends EventsScope {
    * @memberof StatsAnalyzer
    * @returns {void}
    */
-  emitStartStopEvents = (mediaType, previousValue, currentValue, isLocal) => {
+  emitStartStopEvents = (
+    mediaType: string,
+    previousValue: number,
+    currentValue: number,
+    isLocal: boolean
+  ) => {
     if (mediaType !== 'audio' && mediaType !== 'video' && mediaType !== 'share') {
       throw new Error(`Unsupported mediaType: ${mediaType}`);
     }
@@ -438,32 +515,32 @@ export class StatsAnalyzer extends EventsScope {
     // eslint-disable-next-line no-param-reassign
     if (currentValue === undefined) currentValue = 0;
 
-    const lastEmittedEvent = isLocal ? this.lastEmittedStartStopEvent[mediaType].local : this.lastEmittedStartStopEvent[mediaType].remote;
+    const lastEmittedEvent = isLocal
+      ? this.lastEmittedStartStopEvent[mediaType].local
+      : this.lastEmittedStartStopEvent[mediaType].remote;
 
     let newEvent;
 
-    if ((currentValue - previousValue) > 0) {
+    if (currentValue - previousValue > 0) {
       newEvent = isLocal ? EVENTS.LOCAL_MEDIA_STARTED : EVENTS.REMOTE_MEDIA_STARTED;
-    }
-    else if ((currentValue === previousValue) && currentValue > 0) {
+    } else if (currentValue === previousValue && currentValue > 0) {
       newEvent = isLocal ? EVENTS.LOCAL_MEDIA_STOPPED : EVENTS.REMOTE_MEDIA_STOPPED;
     }
 
     if (newEvent && lastEmittedEvent !== newEvent) {
       if (isLocal) {
         this.lastEmittedStartStopEvent[mediaType].local = newEvent;
-      }
-      else {
+      } else {
         this.lastEmittedStartStopEvent[mediaType].remote = newEvent;
       }
       this.emit(
         {
           file: 'statsAnalyzer/index',
-          function: 'compareLastStatsResult'
+          function: 'compareLastStatsResult',
         },
         newEvent,
         {
-          type: mediaType
+          type: mediaType,
         }
       );
     }
@@ -476,7 +553,7 @@ export class StatsAnalyzer extends EventsScope {
    * @memberof StatsAnalyzer
    * @returns {void}
    */
-  compareLastStatsResult() {
+  private compareLastStatsResult() {
     if (this.lastStatsResults !== null && this.meetingMediaStatus) {
       // compare audio stats sent
       let mediaType = STATS.AUDIO_CORRELATE;
@@ -487,54 +564,98 @@ export class StatsAnalyzer extends EventsScope {
         currentStats = this.statsResults[mediaType].send;
         previousStats = this.lastStatsResults[mediaType].send;
 
-        if (currentStats.totalPacketsSent === previousStats.totalPacketsSent || currentStats.totalPacketsSent === 0) {
-          LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`);
-        }
-        else {
-          if (currentStats.totalAudioEnergy === previousStats.totalAudioEnergy || currentStats.totalAudioEnergy === 0) {
-            LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Energy present`);
+        if (
+          currentStats.totalPacketsSent === previousStats.totalPacketsSent ||
+          currentStats.totalPacketsSent === 0
+        ) {
+          LoggerProxy.logger.info(
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`
+          );
+        } else {
+          if (
+            currentStats.totalAudioEnergy === previousStats.totalAudioEnergy ||
+            currentStats.totalAudioEnergy === 0
+          ) {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Energy present`
+            );
           }
 
           if (currentStats.audioLevel === 0) {
-            LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> ${mediaType} level is 0 for the user`);
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> ${mediaType} level is 0 for the user`
+            );
           }
         }
 
-        this.emitStartStopEvents(mediaType, previousStats.totalPacketsSent, currentStats.totalPacketsSent, true);
+        this.emitStartStopEvents(
+          mediaType,
+          previousStats.totalPacketsSent,
+          currentStats.totalPacketsSent,
+          true
+        );
       }
 
       if (this.meetingMediaStatus.expected.receiveAudio) {
-      // compare audio stats received
+        // compare audio stats received
         currentStats = this.statsResults[mediaType].recv;
         previousStats = this.lastStatsResults[mediaType].recv;
 
-        if (currentStats.totalPacketsReceived === previousStats.totalPacketsReceived || currentStats.totalPacketsReceived === 0) {
-          LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets received`);
-        }
-        else if (currentStats.totalSamplesReceived === previousStats.totalSamplesReceived ||
-          currentStats.totalSamplesReceived === 0) {
-          LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} samples received`);
+        if (
+          currentStats.totalPacketsReceived === previousStats.totalPacketsReceived ||
+          currentStats.totalPacketsReceived === 0
+        ) {
+          LoggerProxy.logger.info(
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets received`
+          );
+        } else if (
+          currentStats.totalSamplesReceived === previousStats.totalSamplesReceived ||
+          currentStats.totalSamplesReceived === 0
+        ) {
+          LoggerProxy.logger.info(
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} samples received`
+          );
         }
 
-        this.emitStartStopEvents(mediaType, previousStats.totalPacketsReceived, currentStats.totalPacketsReceived, false);
+        this.emitStartStopEvents(
+          mediaType,
+          previousStats.totalPacketsReceived,
+          currentStats.totalPacketsReceived,
+          false
+        );
       }
 
       mediaType = STATS.VIDEO_CORRELATE;
       if (this.meetingMediaStatus.expected.sendVideo) {
-      // compare video stats sent
+        // compare video stats sent
         currentStats = this.statsResults[mediaType].send;
         previousStats = this.lastStatsResults[mediaType].send;
 
-        if (currentStats.totalPacketsSent === previousStats.totalPacketsSent || currentStats.totalPacketsSent === 0) {
-          LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`);
-        }
-        else {
-          if (currentStats.framesEncoded === previousStats.framesEncoded || currentStats.framesEncoded === 0) {
-            LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames Encoded`);
+        if (
+          currentStats.totalPacketsSent === previousStats.totalPacketsSent ||
+          currentStats.totalPacketsSent === 0
+        ) {
+          LoggerProxy.logger.info(
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`
+          );
+        } else {
+          if (
+            currentStats.framesEncoded === previousStats.framesEncoded ||
+            currentStats.framesEncoded === 0
+          ) {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames Encoded`
+            );
           }
 
-          if (this.statsResults.resolutions[mediaType].send.framesSent === this.lastStatsResults.resolutions[mediaType].send.framesSent || this.statsResults.resolutions[mediaType].send.framesSent === 0) {
-            LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames sent`);
+          if (
+            this.statsResults.resolutions[mediaType].send.framesSent ===
+              this.lastStatsResults.resolutions[mediaType].send.framesSent ||
+            this.statsResults.resolutions[mediaType].send.framesSent === 0
+          ) {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames sent`
+            );
           }
         }
 
@@ -546,27 +667,48 @@ export class StatsAnalyzer extends EventsScope {
         );
       }
 
-
       if (this.meetingMediaStatus.expected.receiveVideo) {
-      // compare video stats reveived
+        // compare video stats reveived
 
         currentStats = this.statsResults[mediaType].recv;
         previousStats = this.lastStatsResults[mediaType].recv;
 
-        if (currentStats.totalPacketsReceived === previousStats.totalPacketsReceived || currentStats.totalPacketsReceived === 0) {
-          LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets received`);
-        }
-        else {
-          if (this.statsResults.resolutions[mediaType].recv.framesReceived === this.lastStatsResults.resolutions[mediaType].recv.framesReceived || this.statsResults.resolutions[mediaType].recv.framesReceived === 0) {
-            LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames received`);
+        if (
+          currentStats.totalPacketsReceived === previousStats.totalPacketsReceived ||
+          currentStats.totalPacketsReceived === 0
+        ) {
+          LoggerProxy.logger.info(
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets received`
+          );
+        } else {
+          if (
+            this.statsResults.resolutions[mediaType].recv.framesReceived ===
+              this.lastStatsResults.resolutions[mediaType].recv.framesReceived ||
+            this.statsResults.resolutions[mediaType].recv.framesReceived === 0
+          ) {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames received`
+            );
           }
 
-          if (this.statsResults[mediaType].recv.framesDecoded === this.lastStatsResults[mediaType].recv.framesDecoded || this.statsResults.resolutions[mediaType].send.framesDecoded === 0) {
-            LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames decoded`);
+          if (
+            this.statsResults[mediaType].recv.framesDecoded ===
+              this.lastStatsResults[mediaType].recv.framesDecoded ||
+            this.statsResults.resolutions[mediaType].send.framesDecoded === 0
+          ) {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames decoded`
+            );
           }
 
-          if (this.statsResults.resolutions[mediaType].recv.framesDropped - this.lastStatsResults.resolutions[mediaType].recv.framesDropped > 10) {
-            LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> ${mediaType} frames are getting dropped`);
+          if (
+            this.statsResults.resolutions[mediaType].recv.framesDropped -
+              this.lastStatsResults.resolutions[mediaType].recv.framesDropped >
+            10
+          ) {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> ${mediaType} frames are getting dropped`
+            );
           }
         }
 
@@ -580,21 +722,36 @@ export class StatsAnalyzer extends EventsScope {
 
       mediaType = STATS.SHARE_CORRELATE;
       if (this.meetingMediaStatus.expected.sendShare) {
-      // compare share stats sent
+        // compare share stats sent
 
         currentStats = this.statsResults[mediaType].send;
         previousStats = this.lastStatsResults[mediaType].send;
 
-        if (currentStats.totalPacketsSent === previousStats.totalPacketsSent || currentStats.totalPacketsSent === 0) {
-          LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`);
-        }
-        else {
-          if (currentStats.framesEncoded === previousStats.framesEncoded || currentStats.framesEncoded === 0) {
-            LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames getting encoded`);
+        if (
+          currentStats.totalPacketsSent === previousStats.totalPacketsSent ||
+          currentStats.totalPacketsSent === 0
+        ) {
+          LoggerProxy.logger.info(
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`
+          );
+        } else {
+          if (
+            currentStats.framesEncoded === previousStats.framesEncoded ||
+            currentStats.framesEncoded === 0
+          ) {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames getting encoded`
+            );
           }
 
-          if (this.statsResults.resolutions[mediaType].send.framesSent === this.lastStatsResults.resolutions[mediaType].send.framesSent || this.statsResults.resolutions[mediaType].send.framesSent === 0) {
-            LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames sent`);
+          if (
+            this.statsResults.resolutions[mediaType].send.framesSent ===
+              this.lastStatsResults.resolutions[mediaType].send.framesSent ||
+            this.statsResults.resolutions[mediaType].send.framesSent === 0
+          ) {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames sent`
+            );
           }
         }
 
@@ -603,20 +760,42 @@ export class StatsAnalyzer extends EventsScope {
         currentStats = this.statsResults[mediaType].recv;
         previousStats = this.lastStatsResults[mediaType].recv;
 
-        if (currentStats.totalPacketsReceived === previousStats.totalPacketsReceived || currentStats.totalPacketsSent === 0) {
-          LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets received`);
-        }
-        else {
-          if (this.statsResults.resolutions[mediaType].recv.framesReceived === this.lastStatsResults.resolutions[mediaType].recv.framesReceived || this.statsResults.resolutions[mediaType].recv.framesReceived === 0) {
-            LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames received`);
+        if (
+          currentStats.totalPacketsReceived === previousStats.totalPacketsReceived ||
+          currentStats.totalPacketsSent === 0
+        ) {
+          LoggerProxy.logger.info(
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets received`
+          );
+        } else {
+          if (
+            this.statsResults.resolutions[mediaType].recv.framesReceived ===
+              this.lastStatsResults.resolutions[mediaType].recv.framesReceived ||
+            this.statsResults.resolutions[mediaType].recv.framesReceived === 0
+          ) {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames received`
+            );
           }
 
-          if (this.statsResults[mediaType].recv.framesDecoded === this.lastStatsResults[mediaType].recv.framesDecoded || this.statsResults.resolutions[mediaType].send.framesDecoded === 0) {
-            LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames decoded`);
+          if (
+            this.statsResults[mediaType].recv.framesDecoded ===
+              this.lastStatsResults[mediaType].recv.framesDecoded ||
+            this.statsResults.resolutions[mediaType].send.framesDecoded === 0
+          ) {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames decoded`
+            );
           }
 
-          if (this.statsResults.resolutions[mediaType].recv.framesDropped - this.lastStatsResults.resolutions[mediaType].recv.framesDropped > 10) {
-            LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> ${mediaType} frames are getting dropped`);
+          if (
+            this.statsResults.resolutions[mediaType].recv.framesDropped -
+              this.lastStatsResults.resolutions[mediaType].recv.framesDropped >
+            10
+          ) {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> ${mediaType} frames are getting dropped`
+            );
           }
         }
 
@@ -634,13 +813,18 @@ export class StatsAnalyzer extends EventsScope {
    * @memberof StatsAnalyzer
    * @returns {Promise}
    */
-  getStatsAndParse() {
+  private getStatsAndParse() {
     if (!this.mediaConnection) {
       return Promise.resolve();
     }
 
-    if (this.mediaConnection && this.mediaConnection.getConnectionState() === MC.ConnectionState.Failed) {
-      LoggerProxy.logger.trace('StatsAnalyzer:index#getStatsAndParse --> media connection is in failed state');
+    if (
+      this.mediaConnection &&
+      this.mediaConnection.getConnectionState() === ConnectionState.Failed
+    ) {
+      LoggerProxy.logger.trace(
+        'StatsAnalyzer:index#getStatsAndParse --> media connection is in failed state'
+      );
 
       return Promise.resolve();
     }
@@ -648,20 +832,47 @@ export class StatsAnalyzer extends EventsScope {
     LoggerProxy.logger.trace('StatsAnalyzer:index#getStatsAndParse --> Collecting Stats');
 
     return this.mediaConnection.getTransceiverStats().then((transceiverStats) => {
-      this.filterAndParseGetStatsResults(transceiverStats.video.sender, STATS.VIDEO_CORRELATE, true);
-      this.filterAndParseGetStatsResults(transceiverStats.video.receiver, STATS.VIDEO_CORRELATE, false);
-      this.filterAndParseGetStatsResults(transceiverStats.audio.sender, STATS.AUDIO_CORRELATE, true);
-      this.filterAndParseGetStatsResults(transceiverStats.audio.receiver, STATS.AUDIO_CORRELATE, false);
-      this.filterAndParseGetStatsResults(transceiverStats.screenShareVideo.sender, STATS.SHARE_CORRELATE, true);
-      this.filterAndParseGetStatsResults(transceiverStats.screenShareVideo.receiver, STATS.SHARE_CORRELATE, false);
+      this.filterAndParseGetStatsResults(
+        transceiverStats.video.sender,
+        STATS.VIDEO_CORRELATE,
+        true
+      );
+      this.filterAndParseGetStatsResults(
+        transceiverStats.video.receiver,
+        STATS.VIDEO_CORRELATE,
+        false
+      );
+      this.filterAndParseGetStatsResults(
+        transceiverStats.audio.sender,
+        STATS.AUDIO_CORRELATE,
+        true
+      );
+      this.filterAndParseGetStatsResults(
+        transceiverStats.audio.receiver,
+        STATS.AUDIO_CORRELATE,
+        false
+      );
+      this.filterAndParseGetStatsResults(
+        transceiverStats.screenShareVideo.sender,
+        STATS.SHARE_CORRELATE,
+        true
+      );
+      this.filterAndParseGetStatsResults(
+        transceiverStats.screenShareVideo.receiver,
+        STATS.SHARE_CORRELATE,
+        false
+      );
 
       // updates the current direction of media
       this.statsResults[STATS.AUDIO_CORRELATE].direction = transceiverStats.audio.currentDirection;
       this.statsResults[STATS.VIDEO_CORRELATE].direction = transceiverStats.video.currentDirection;
-      this.statsResults[STATS.SHARE_CORRELATE].direction = transceiverStats.screenShareVideo.currentDirection;
+      this.statsResults[STATS.SHARE_CORRELATE].direction =
+        transceiverStats.screenShareVideo.currentDirection;
 
-      this.statsResults[STATS.AUDIO_CORRELATE][STATS.SEND_DIRECTION].trackLabel = transceiverStats.audio.localTrackLabel;
-      this.statsResults[STATS.VIDEO_CORRELATE][STATS.SEND_DIRECTION].trackLabel = transceiverStats.video.localTrackLabel;
+      this.statsResults[STATS.AUDIO_CORRELATE][STATS.SEND_DIRECTION].trackLabel =
+        transceiverStats.audio.localTrackLabel;
+      this.statsResults[STATS.VIDEO_CORRELATE][STATS.SEND_DIRECTION].trackLabel =
+        transceiverStats.video.localTrackLabel;
 
       this.compareLastStatsResult();
 
@@ -669,7 +880,9 @@ export class StatsAnalyzer extends EventsScope {
       // DO Deep copy, for some reason it takes the reference all the time rather then old value set
       this.lastStatsResults = JSON.parse(JSON.stringify(this.statsResults));
 
-      LoggerProxy.logger.trace('StatsAnalyzer:index#getStatsAndParse --> Finished Collecting Stats');
+      LoggerProxy.logger.trace(
+        'StatsAnalyzer:index#getStatsAndParse --> Finished Collecting Stats'
+      );
     });
   }
 
@@ -680,7 +893,7 @@ export class StatsAnalyzer extends EventsScope {
    * @param {*} type
    * @returns {void}
    */
-  processOutboundRTPResult(result, type) {
+  private processOutboundRTPResult(result: any, type: any) {
     const mediaType = type || STATS.AUDIO_CORRELATE;
     const sendrecvType = STATS.SEND_DIRECTION;
 
@@ -694,10 +907,12 @@ export class StatsAnalyzer extends EventsScope {
         this.statsResults.internal[mediaType][sendrecvType].framesEncoded = result.framesEncoded;
       }
       if (!this.statsResults.internal[mediaType][sendrecvType].keyFramesEncoded) {
-        this.statsResults.internal[mediaType][sendrecvType].keyFramesEncoded = result.keyFramesEncoded;
+        this.statsResults.internal[mediaType][sendrecvType].keyFramesEncoded =
+          result.keyFramesEncoded;
       }
 
-      const bytes = result.bytesSent - this.statsResults.internal[mediaType][sendrecvType].prevBytesSent;
+      const bytes =
+        result.bytesSent - this.statsResults.internal[mediaType][sendrecvType].prevBytesSent;
 
       this.statsResults.internal[mediaType][sendrecvType].prevBytesSent = result.bytesSent;
 
@@ -706,15 +921,19 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[mediaType][sendrecvType].availableBandwidth = kilobytes.toFixed(1);
       this.statsResults[mediaType].bytesSent = kilobytes;
 
-      this.statsResults[mediaType][sendrecvType].framesEncoded = result.framesEncoded - this.statsResults.internal[mediaType][sendrecvType].framesEncoded;
-      this.statsResults[mediaType][sendrecvType].keyFramesEncoded = result.keyFramesEncoded - this.statsResults.internal[mediaType][sendrecvType].keyFramesEncoded;
+      this.statsResults[mediaType][sendrecvType].framesEncoded =
+        result.framesEncoded - this.statsResults.internal[mediaType][sendrecvType].framesEncoded;
+      this.statsResults[mediaType][sendrecvType].keyFramesEncoded =
+        result.keyFramesEncoded -
+        this.statsResults.internal[mediaType][sendrecvType].keyFramesEncoded;
       this.statsResults.internal[mediaType].outboundRtpId = result.id;
 
       if (!this.statsResults.internal[mediaType][sendrecvType].packetsSent) {
         this.statsResults.internal[mediaType][sendrecvType].packetsSent = result.packetsSent;
       }
 
-      this.statsResults[mediaType][sendrecvType].packetsSent = result.packetsSent - this.statsResults.internal[mediaType][sendrecvType].packetsSent;
+      this.statsResults[mediaType][sendrecvType].packetsSent =
+        result.packetsSent - this.statsResults.internal[mediaType][sendrecvType].packetsSent;
       this.statsResults.internal[mediaType][sendrecvType].packetsSent = result.packetsSent;
 
       // Data saved to send MQA metrics
@@ -726,17 +945,21 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[mediaType][sendrecvType].totalFirCount = result.firCount;
       this.statsResults[mediaType][sendrecvType].framesSent = result.framesSent;
       this.statsResults[mediaType][sendrecvType].framesEncoded = result.framesEncoded;
-      this.statsResults[mediaType][sendrecvType].encoderImplementation = result.encoderImplementation;
-      this.statsResults[mediaType][sendrecvType].qualityLimitationReason = result.qualityLimitationReason;
-      this.statsResults[mediaType][sendrecvType].qualityLimitationResolutionChanges = result.qualityLimitationResolutionChanges;
-      this.statsResults[mediaType][sendrecvType].retransmittedPacketsSent = result.retransmittedPacketsSent;
+      this.statsResults[mediaType][sendrecvType].encoderImplementation =
+        result.encoderImplementation;
+      this.statsResults[mediaType][sendrecvType].qualityLimitationReason =
+        result.qualityLimitationReason;
+      this.statsResults[mediaType][sendrecvType].qualityLimitationResolutionChanges =
+        result.qualityLimitationResolutionChanges;
+      this.statsResults[mediaType][sendrecvType].retransmittedPacketsSent =
+        result.retransmittedPacketsSent;
       this.statsResults[mediaType][sendrecvType].totalBytesSent = result.bytesSent;
       this.statsResults[mediaType][sendrecvType].headerBytesSent = result.headerBytesSent;
-      this.statsResults[mediaType][sendrecvType].retransmittedBytesSent = result.retransmittedBytesSent;
+      this.statsResults[mediaType][sendrecvType].retransmittedBytesSent =
+        result.retransmittedBytesSent;
     }
   }
 
-
   /**
    * Processes InboundRTP stats result and stores
    * @private
@@ -744,7 +967,7 @@ export class StatsAnalyzer extends EventsScope {
    * @param {*} type
    * @returns {void}
    */
-  processInboundRTPResult(result, type) {
+  private processInboundRTPResult(result: any, type: any) {
     const mediaType = type || STATS.AUDIO_CORRELATE;
     const sendrecvType = STATS.RECEIVE_DIRECTION;
 
@@ -752,7 +975,8 @@ export class StatsAnalyzer extends EventsScope {
       let kilobytes = 0;
 
       if (!this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived) {
-        this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived = result.bytesReceived;
+        this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived =
+          result.bytesReceived;
       }
 
       if (!this.statsResults.internal[mediaType][sendrecvType].pliCount) {
@@ -764,14 +988,18 @@ export class StatsAnalyzer extends EventsScope {
       }
 
       if (!this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived) {
-        this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived = result.packetsReceived;
+        this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived =
+          result.packetsReceived;
       }
 
       if (!this.statsResults.internal[mediaType][sendrecvType].lastPacketReceivedTimestamp) {
-        this.statsResults.internal[mediaType][sendrecvType].lastPacketReceivedTimestamp = result.lastPacketReceivedTimestamp;
+        this.statsResults.internal[mediaType][sendrecvType].lastPacketReceivedTimestamp =
+          result.lastPacketReceivedTimestamp;
       }
 
-      const bytes = result.bytesReceived - (this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived);
+      const bytes =
+        result.bytesReceived -
+        this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived;
 
       this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived = result.bytesReceived;
 
@@ -779,35 +1007,52 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[mediaType][sendrecvType].availableBandwidth = kilobytes.toFixed(1);
       this.statsResults[mediaType].bytesReceived = kilobytes.toFixed(1);
 
-      this.statsResults[mediaType][sendrecvType].pliCount = result.pliCount - this.statsResults.internal[mediaType][sendrecvType].pliCount;
-      this.statsResults[mediaType][sendrecvType].currentPacketsLost = result.packetsLost - this.statsResults.internal[mediaType][sendrecvType].packetsLost;
+      this.statsResults[mediaType][sendrecvType].pliCount =
+        result.pliCount - this.statsResults.internal[mediaType][sendrecvType].pliCount;
+      this.statsResults[mediaType][sendrecvType].currentPacketsLost =
+        result.packetsLost - this.statsResults.internal[mediaType][sendrecvType].packetsLost;
       if (this.statsResults[mediaType][sendrecvType].currentPacketsLost < 0) {
         this.statsResults[mediaType][sendrecvType].currentPacketsLost = 0;
       }
 
-      this.statsResults[mediaType][sendrecvType].packetsReceived = result.packetsReceived - this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived;
-      this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived = result.packetsReceived;
+      this.statsResults[mediaType][sendrecvType].packetsReceived =
+        result.packetsReceived -
+        this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived;
+      this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived =
+        result.packetsReceived;
 
       if (this.statsResults[mediaType][sendrecvType].packetsReceived === 0) {
-        LoggerProxy.logger.info(`StatsAnalyzer:index#processInboundRTPResult --> No packets received for ${mediaType} `, this.statsResults[mediaType][sendrecvType].packetsReceived);
+        LoggerProxy.logger.info(
+          `StatsAnalyzer:index#processInboundRTPResult --> No packets received for ${mediaType} `,
+          this.statsResults[mediaType][sendrecvType].packetsReceived
+        );
       }
 
       //  Check the over all packet Lost ratio
-      this.statsResults[mediaType][sendrecvType].currentPacketLossRatio = this.statsResults[mediaType][sendrecvType].currentPacketsLost > 0 ? this.statsResults[mediaType][sendrecvType].currentPacketsLost / (this.statsResults[mediaType][sendrecvType].packetsReceived + this.statsResults[mediaType][sendrecvType].currentPacketsLost) : 0;
+      this.statsResults[mediaType][sendrecvType].currentPacketLossRatio =
+        this.statsResults[mediaType][sendrecvType].currentPacketsLost > 0
+          ? this.statsResults[mediaType][sendrecvType].currentPacketsLost /
+            (this.statsResults[mediaType][sendrecvType].packetsReceived +
+              this.statsResults[mediaType][sendrecvType].currentPacketsLost)
+          : 0;
       if (this.statsResults[mediaType][sendrecvType].currentPacketLossRatio > 3) {
-        LoggerProxy.logger.info('StatsAnalyzer:index#processInboundRTPResult --> Packets getting lost from the receiver ', this.statsResults[mediaType][sendrecvType].currentPacketLossRatio);
+        LoggerProxy.logger.info(
+          'StatsAnalyzer:index#processInboundRTPResult --> Packets getting lost from the receiver ',
+          this.statsResults[mediaType][sendrecvType].currentPacketLossRatio
+        );
       }
 
       // TODO: check the packet loss value is negative values here
 
       if (result.packetsLost) {
-        this.statsResults[mediaType][sendrecvType].totalPacketsLost = result.packetsLost > 0 ? result.packetsLost : -result.packetsLost;
-      }
-      else {
+        this.statsResults[mediaType][sendrecvType].totalPacketsLost =
+          result.packetsLost > 0 ? result.packetsLost : -result.packetsLost;
+      } else {
         this.statsResults[mediaType][sendrecvType].totalPacketsLost = 0;
       }
 
-      this.statsResults[mediaType][sendrecvType].lastPacketReceivedTimestamp = result.lastPacketReceivedTimestamp;
+      this.statsResults[mediaType][sendrecvType].lastPacketReceivedTimestamp =
+        result.lastPacketReceivedTimestamp;
 
       // From Thin
       this.statsResults[mediaType][sendrecvType].totalNackCount = result.nackCount;
@@ -815,10 +1060,10 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[mediaType][sendrecvType].framesDecoded = result.framesDecoded;
       this.statsResults[mediaType][sendrecvType].keyFramesDecoded = result.keyFramesDecoded;
 
-      this.statsResults[mediaType][sendrecvType].decoderImplementation = result.decoderImplementation;
+      this.statsResults[mediaType][sendrecvType].decoderImplementation =
+        result.decoderImplementation;
       this.statsResults[mediaType][sendrecvType].totalPacketsReceived = result.packetsReceived;
 
-
       this.statsResults[mediaType][sendrecvType].fecPacketsDiscarded = result.fecPacketsDiscarded;
       this.statsResults[mediaType][sendrecvType].fecPacketsReceived = result.fecPacketsReceived;
       this.statsResults[mediaType][sendrecvType].totalBytesReceived = result.bytesReceived;
@@ -830,8 +1075,10 @@ export class StatsAnalyzer extends EventsScope {
 
       this.statsResults[mediaType][sendrecvType].audioLevel = result.audioLevel;
       this.statsResults[mediaType][sendrecvType].totalAudioEnergy = result.totalAudioEnergy;
-      this.statsResults[mediaType][sendrecvType].totalSamplesReceived = result.totalSamplesReceived || 0;
-      this.statsResults[mediaType][sendrecvType].totalSamplesDecoded = result.totalSamplesDecoded || 0;
+      this.statsResults[mediaType][sendrecvType].totalSamplesReceived =
+        result.totalSamplesReceived || 0;
+      this.statsResults[mediaType][sendrecvType].totalSamplesDecoded =
+        result.totalSamplesDecoded || 0;
       this.statsResults[mediaType][sendrecvType].concealedSamples = result.concealedSamples || 0;
     }
   }
@@ -846,7 +1093,7 @@ export class StatsAnalyzer extends EventsScope {
    *
    * @returns {void}
    */
-  parseCandidate = (result, type, isSender, isRemote) => {
+  parseCandidate = (result: any, type: any, isSender: boolean, isRemote: boolean) => {
     if (!result || !result.id) {
       return;
     }
@@ -875,7 +1122,10 @@ export class StatsAnalyzer extends EventsScope {
       RemoteNetworkType[result.id] = [];
     }
 
-    if (result.candidateType && RemoteCandidateType[result.id].indexOf(result.candidateType) === -1) {
+    if (
+      result.candidateType &&
+      RemoteCandidateType[result.id].indexOf(result.candidateType) === -1
+    ) {
       RemoteCandidateType[result.id].push(result.candidateType);
     }
 
@@ -883,7 +1133,10 @@ export class StatsAnalyzer extends EventsScope {
       RemoteTransport[result.id].push(result.protocol.toUpperCase());
     }
 
-    if (result.ip && RemoteIpAddress[result.id].indexOf(`${result.ip}:${result.portNumber}`) === -1) {
+    if (
+      result.ip &&
+      RemoteIpAddress[result.id].indexOf(`${result.ip}:${result.portNumber}`) === -1
+    ) {
       RemoteIpAddress[result.id].push(`${result.ip}`); // TODO: Add ports
     }
 
@@ -900,13 +1153,16 @@ export class StatsAnalyzer extends EventsScope {
       transport: RemoteTransport[result.id],
       timestamp: result.time,
       id: result.id,
-      type: result.type
+      type: result.type,
     };
 
     this.statsResults.connectionType[ipType].candidateType = RemoteCandidateType[result.id];
     this.statsResults.connectionType[ipType].ipAddress = RemoteIpAddress[result.id];
 
-    this.statsResults.connectionType[ipType].networkType = RemoteNetworkType[result.id][0] === NETWORK_TYPE.VPN ? NETWORK_TYPE.UNKNOWN : RemoteNetworkType[result.id][0];
+    this.statsResults.connectionType[ipType].networkType =
+      RemoteNetworkType[result.id][0] === NETWORK_TYPE.VPN
+        ? NETWORK_TYPE.UNKNOWN
+        : RemoteNetworkType[result.id][0];
     this.statsResults.connectionType[ipType].transport = RemoteTransport[result.id];
 
     this.statsResults[type][sendRecvType].totalRoundTripTime = result.totalRoundTripTime;
@@ -921,13 +1177,14 @@ export class StatsAnalyzer extends EventsScope {
    * @returns {void}
    * @memberof StatsAnalyzer
    */
-  processTrackResult(result, mediaType) {
+  private processTrackResult(result: any, mediaType: any) {
     if (!result || result.type !== 'track') {
       return;
     }
     if (result.type !== 'track') return;
 
-    const sendrecvType = result.remoteSource === true ? STATS.RECEIVE_DIRECTION : STATS.SEND_DIRECTION;
+    const sendrecvType =
+      result.remoteSource === true ? STATS.RECEIVE_DIRECTION : STATS.SEND_DIRECTION;
 
     if (result.frameWidth && result.frameHeight) {
       this.statsResults.resolutions[mediaType][sendrecvType].width = result.frameWidth;
@@ -942,18 +1199,21 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults.resolutions[mediaType][sendrecvType].framesDropped = result.framesDropped;
     }
 
-
     if (result.trackIdentifier && mediaType !== STATS.AUDIO_CORRELATE) {
-      this.statsResults.resolutions[mediaType][sendrecvType].trackIdentifier = result.trackIdentifier;
+      this.statsResults.resolutions[mediaType][sendrecvType].trackIdentifier =
+        result.trackIdentifier;
 
       const jitterBufferDelay = result && result.jitterBufferDelay;
       const jitterBufferEmittedCount = result && result.jitterBufferEmittedCount;
 
-      this.statsResults.resolutions[mediaType][sendrecvType].avgJitterDelay = jitterBufferEmittedCount && (+jitterBufferDelay / +jitterBufferEmittedCount);
+      this.statsResults.resolutions[mediaType][sendrecvType].avgJitterDelay =
+        jitterBufferEmittedCount && +jitterBufferDelay / +jitterBufferEmittedCount;
 
       // Used to calculate the jitter
-      this.statsResults.resolutions[mediaType][sendrecvType].jitterBufferDelay = result.jitterBufferDelay;
-      this.statsResults.resolutions[mediaType][sendrecvType].jitterBufferEmittedCount = result.jitterBufferEmittedCount;
+      this.statsResults.resolutions[mediaType][sendrecvType].jitterBufferDelay =
+        result.jitterBufferDelay;
+      this.statsResults.resolutions[mediaType][sendrecvType].jitterBufferEmittedCount =
+        result.jitterBufferEmittedCount;
     }
   }
 
@@ -965,16 +1225,19 @@ export class StatsAnalyzer extends EventsScope {
    * @returns {void}
    * @memberof StatsAnalyzer
    */
-  compareSentAndReceived(result, type) {
+  private compareSentAndReceived(result: any, type: any) {
     if (!type) {
       return;
     }
 
     const mediaType = type;
 
-    if (!this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver) { this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver = result.packetsLost; }
+    if (!this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver) {
+      this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver = result.packetsLost;
+    }
 
-    const currentPacketLoss = result.packetsLost - this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver;
+    const currentPacketLoss =
+      result.packetsLost - this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver;
 
     this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver = result.packetsLost;
     this.statsResults[mediaType].send.packetsLostOnReceiver = currentPacketLoss;
@@ -988,18 +1251,31 @@ export class StatsAnalyzer extends EventsScope {
     this.statsResults[mediaType].send.reportsReceived = result.reportsReceived;
 
     // Total packloss ratio on this video section of the call
-    this.statsResults[mediaType].send.overAllPacketLossRatio = this.statsResults[mediaType].send.totalPacketsLostOnReceiver > 0 ? this.statsResults[mediaType].send.totalPacketsLostOnReceiver / this.statsResults[mediaType].send.totalPacketsSent : 0;
-    this.statsResults[mediaType].send.currentPacketLossRatio = this.statsResults[mediaType].send.packetsLostOnReceiver > 0 ? this.statsResults[mediaType].send.packetsLostOnReceiver * 100 / (this.statsResults[mediaType].send.packetsSent + this.statsResults[mediaType].send.packetsLostOnReceiver) : 0;
-
-    if (this.statsResults[mediaType].send.maxPacketLossRatio < this.statsResults[mediaType].send.currentPacketLossRatio) {
-      this.statsResults[mediaType].send.maxPacketLossRatio = this.statsResults[mediaType].send.currentPacketLossRatio;
+    this.statsResults[mediaType].send.overAllPacketLossRatio =
+      this.statsResults[mediaType].send.totalPacketsLostOnReceiver > 0
+        ? this.statsResults[mediaType].send.totalPacketsLostOnReceiver /
+          this.statsResults[mediaType].send.totalPacketsSent
+        : 0;
+    this.statsResults[mediaType].send.currentPacketLossRatio =
+      this.statsResults[mediaType].send.packetsLostOnReceiver > 0
+        ? (this.statsResults[mediaType].send.packetsLostOnReceiver * 100) /
+          (this.statsResults[mediaType].send.packetsSent +
+            this.statsResults[mediaType].send.packetsLostOnReceiver)
+        : 0;
+
+    if (
+      this.statsResults[mediaType].send.maxPacketLossRatio <
+      this.statsResults[mediaType].send.currentPacketLossRatio
+    ) {
+      this.statsResults[mediaType].send.maxPacketLossRatio =
+        this.statsResults[mediaType].send.currentPacketLossRatio;
     }
 
     if (result.type === 'remote-inbound-rtp') {
       this.networkQualityMonitor.determineUplinkNetworkQuality({
         mediaType,
         remoteRtpResults: result,
-        statsAnalyzerCurrentStats: this.statsResults
+        statsAnalyzerCurrentStats: this.statsResults,
       });
     }
   }