@webex/plugin-meetings 2.19.1 → 2.19.2

package/src/statsAnalyzer/index.js

@@ -1,8 +1,7 @@
 import {cloneDeep} from 'lodash';
 
 import EventsScope from '../common/events/events-scope';
-import {EVENT_TRIGGERS,
-  DEFAULT_GET_STATS_FILTER, CONNECTION_STATE, STATS, MQA_INTEVAL, NETWORK_TYPE, MEDIA_DEVICES, _UNKNOWN_} from '../constants';
+import {DEFAULT_GET_STATS_FILTER, CONNECTION_STATE, STATS, MQA_INTEVAL, NETWORK_TYPE, MEDIA_DEVICES, _UNKNOWN_} from '../constants';
 import mqaData from '../mediaQualityMetrics/config';
 import LoggerProxy from '../common/logs/logger-proxy';
 
@@ -14,16 +13,13 @@ import {
   getVideoReceiverMqa
 } from './mqaUtil';
 
-
-/**
-  * Meeting High Packet Loss Event
-  * Emitted when ever there is high packet loss detected
-  * @event meeting:highPacketLoss
-  * @type {Object}
-  * @property {String} mediaType Type of media experiencing packet loss
-  * @property {Number} packetLossRatio current packet loss ratio
-  * @memberof StatsAnalyzer
-  */
+export const EVENTS = {
+  MEDIA_QUALITY: 'MEDIA_QUALITY',
+  LOCAL_MEDIA_STARTED: 'LOCAL_MEDIA_STARTED',
+  LOCAL_MEDIA_STOPPED: 'LOCAL_MEDIA_STOPPED',
+  REMOTE_MEDIA_STARTED: 'REMOTE_MEDIA_STARTED',
+  REMOTE_MEDIA_STOPPED: 'REMOTE_MEDIA_STOPPED',
+};
 
 /**
  * Stats Analyzer class that will emit events based on detected quality
@@ -32,7 +28,7 @@ import {
  * @class StatsAnalyzer
  * @extends {EventsScope}
  */
-export default class StatsAnalyzer extends EventsScope {
+export class StatsAnalyzer extends EventsScope {
   /**
    * Creates a new instance of StatsAnalyzer
    * @constructor
@@ -96,6 +92,20 @@ export default class StatsAnalyzer extends EventsScope {
         }
       }
     };
+    this.lastEmittedStartStopEvent = {
+      audio: {
+        local: undefined,
+        remote: undefined,
+      },
+      video: {
+        local: undefined,
+        remote: undefined,
+      },
+      share: {
+        local: undefined,
+        remote: undefined,
+      },
+    };
   }
 
   populateResults(lastMqa) {
@@ -244,7 +254,7 @@ export default class StatsAnalyzer extends EventsScope {
         file: 'statsAnalyzer',
         function: 'sendMqaData'
       },
-      EVENT_TRIGGERS.MEDIA_QUALITY,
+      EVENTS.MEDIA_QUALITY,
       {
         data: mqaData.intervals[0],
         networkType: mqaData.networkType
@@ -270,22 +280,27 @@ export default class StatsAnalyzer extends EventsScope {
    * @public
    * @memberof StatsAnalyzer
    * @param {PeerConnection} peerConnection
-   * @returns {void}
+   * @returns {Promise}
    */
   startAnalyzer(peerConnection) {
     if (!this.statsStarted) {
       this.statsStarted = true;
       this.peerConnection = peerConnection;
-      this.getStatsAndParse();
-      this.statsInterval = setInterval(() => {
-        this.getStatsAndParse();
-      }, this.config.analyzerInterval);
-      // Trigger initial fetch
-      this.sendMqaData();
-      this.mqaInterval = setInterval(() => {
-        this.sendMqaData();
-      }, MQA_INTEVAL);
+
+      return this.getStatsAndParse()
+        .then(() => {
+          this.statsInterval = setInterval(() => {
+            this.getStatsAndParse();
+          }, this.config.analyzerInterval);
+          // Trigger initial fetch
+          this.sendMqaData();
+          this.mqaInterval = setInterval(() => {
+            this.sendMqaData();
+          }, MQA_INTEVAL);
+        });
     }
+
+    return Promise.resolve();
   }
 
   /**
@@ -296,18 +311,27 @@ export default class StatsAnalyzer extends EventsScope {
    * @returns {void}
    */
   stopAnalyzer() {
+    const sendOneLastMqa = this.mqaInterval && this.statsInterval;
+
     if (this.statsInterval) {
-      this.getStatsAndParse();
       clearInterval(this.statsInterval);
-      this.statsInterva = undefined;
+      this.statsInterval = undefined;
     }
 
     if (this.mqaInterval) {
-      this.sendMqaData();
       clearInterval(this.mqaInterval);
-      this.statsInterva = undefined;
+      this.mqaInterval = undefined;
+    }
+
+    if (sendOneLastMqa) {
+      return this.getStatsAndParse().then(() => {
+        this.sendMqaData();
+        this.peerConnection = null;
+      });
     }
     this.peerConnection = null;
+
+    return Promise.resolve();
   }
 
   /**
@@ -389,6 +413,61 @@ export default class StatsAnalyzer extends EventsScope {
     }
   }
 
+  /**
+   * emits started/stopped events for local/remote media by checking
+   * if given values are increasing or not. The previousValue, currentValue
+   * params can be any numerical value like number of receive packets or
+   * decoded frames, etc.
+   *
+   * @private
+   * @param {string} mediaType
+   * @param {number} previousValue - value to compare
+   * @param {number} currentValue - value to compare (must be same type of value as previousValue)
+   * @param {boolean} isLocal - true if stats are for local media being sent out, false for remote media being received
+   * @memberof StatsAnalyzer
+   * @returns {void}
+   */
+  emitStartStopEvents = (mediaType, previousValue, currentValue, isLocal) => {
+    if (mediaType !== 'audio' && mediaType !== 'video' && mediaType !== 'share') {
+      throw new Error(`Unsupported mediaType: ${mediaType}`);
+    }
+
+    // eslint-disable-next-line no-param-reassign
+    if (previousValue === undefined) previousValue = 0;
+    // eslint-disable-next-line no-param-reassign
+    if (currentValue === undefined) currentValue = 0;
+
+    const lastEmittedEvent = isLocal ? this.lastEmittedStartStopEvent[mediaType].local : this.lastEmittedStartStopEvent[mediaType].remote;
+
+    let newEvent;
+
+    if ((currentValue - previousValue) > 0) {
+      newEvent = isLocal ? EVENTS.LOCAL_MEDIA_STARTED : EVENTS.REMOTE_MEDIA_STARTED;
+    }
+    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 {
+        this.lastEmittedStartStopEvent[mediaType].remote = newEvent;
+      }
+      this.emit(
+        {
+          file: 'statsAnalyzer/index',
+          function: 'compareLastStatsResult'
+        },
+        newEvent,
+        {
+          type: mediaType
+        }
+      );
+    }
+  };
+
   /**
    * compares current and previous stats to check if packets are not sent
    *
@@ -420,18 +499,7 @@ export default class StatsAnalyzer extends EventsScope {
           }
         }
 
-        if (previousStats.totalPacketsSent === 0 && currentStats.totalPacketsSent > 0) {
-          this.emit(
-            {
-              file: 'statsAnalyzer/index',
-              function: 'compareLastStatsResult'
-            },
-            EVENT_TRIGGERS.MEETING_MEDIA_LOCAL_STARTED,
-            {
-              type: mediaType.AUDIO
-            }
-          );
-        }
+        this.emitStartStopEvents(mediaType, previousStats.totalPacketsSent, currentStats.totalPacketsSent, true);
       }
 
       if (this.meetingMediaStatus.expected.receiveAudio) {
@@ -446,6 +514,8 @@ export default class StatsAnalyzer extends EventsScope {
           currentStats.totalSamplesReceived === 0) {
           LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} samples received`);
         }
+
+        this.emitStartStopEvents(mediaType, previousStats.totalPacketsReceived, currentStats.totalPacketsReceived, false);
       }
 
       mediaType = STATS.VIDEO_CORRELATE;
@@ -467,18 +537,12 @@ export default class StatsAnalyzer extends EventsScope {
           }
         }
 
-        if (previousStats.framesSent === 0 && currentStats.framesSent > 0) {
-          this.emit(
-            {
-              file: 'statsAnalyzer/index',
-              function: 'compareLastStatsResult'
-            },
-            EVENT_TRIGGERS.MEETING_MEDIA_LOCAL_STARTED,
-            {
-              type: mediaType.VIDEO
-            }
-          );
-        }
+        this.emitStartStopEvents(
+          mediaType,
+          previousStats.framesSent,
+          currentStats.framesSent,
+          true
+        );
       }
 
 
@@ -496,7 +560,7 @@ export default class StatsAnalyzer extends EventsScope {
             LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames received`);
           }
 
-          if (this.statsResults.resolutions[mediaType].recv.framesDecoded === this.lastStatsResults.resolutions[mediaType].recv.framesDecoded || this.statsResults.resolutions[mediaType].send.framesDecoded === 0) {
+          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`);
           }
 
@@ -504,6 +568,13 @@ export default class StatsAnalyzer extends EventsScope {
             LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> ${mediaType} frames are getting dropped`);
           }
         }
+
+        this.emitStartStopEvents(
+          mediaType,
+          previousStats.framesDecoded,
+          currentStats.framesDecoded,
+          false
+        );
       }
 
       mediaType = STATS.SHARE_CORRELATE;
@@ -526,19 +597,6 @@ export default class StatsAnalyzer extends EventsScope {
           }
         }
 
-        if (previousStats.framesSent === 0 && currentStats.framesSent > 0) {
-          this.emit(
-            {
-              file: 'statsAnalyzer/index',
-              function: 'compareLastStatsResult'
-            },
-            EVENT_TRIGGERS.MEETING_MEDIA_LOCAL_STARTED,
-            {
-              type: mediaType.VIDEO
-            }
-          );
-        }
-
         // TODO:need to check receive share value
         // compare share stats reveived
         currentStats = this.statsResults[mediaType].recv;
@@ -552,7 +610,7 @@ export default class StatsAnalyzer extends EventsScope {
             LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames received`);
           }
 
-          if (this.statsResults.resolutions[mediaType].recv.framesDecoded === this.lastStatsResults.resolutions[mediaType].recv.framesDecoded || this.statsResults.resolutions[mediaType].send.framesDecoded === 0) {
+          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`);
           }
 
@@ -560,6 +618,10 @@ export default class StatsAnalyzer extends EventsScope {
             LoggerProxy.logger.info(`StatsAnalyzer:index#compareLastStatsResult --> ${mediaType} frames are getting dropped`);
           }
         }
+
+        // we are not calling emitStartStopEvents() for sending or receiving share because sharing is often started and stopped
+        // in meetings and this.meetingMediaStatus.expected values can be out of sync with the actual packet flow
+        // so we would send "sharing stopped" events incorrectly
       }
     }
   }
@@ -569,58 +631,60 @@ export default class StatsAnalyzer extends EventsScope {
    *
    * @private
    * @memberof StatsAnalyzer
-   * @returns {void}
+   * @returns {Promise}
    */
   getStatsAndParse() {
     if (!this.peerConnection) {
-      return;
+      return Promise.resolve();
     }
 
     if (this.peerConnection && this.peerConnection.connectionState === CONNECTION_STATE.FAILED) {
       LoggerProxy.logger.trace('StatsAnalyzer:index#getStatsAndParse --> PeerConnection is in failed state');
 
-      return;
+      return Promise.resolve();
     }
 
     LoggerProxy.logger.trace('StatsAnalyzer:index#getStatsAndParse --> Collecting Stats');
-    this.peerConnection.videoTransceiver.sender.getStats().then((res) => {
-      this.filterAndParseGetStatsResults(res, STATS.VIDEO_CORRELATE, true);
-    });
 
-    this.peerConnection.videoTransceiver.receiver.getStats().then((res) => {
-      this.filterAndParseGetStatsResults(res, STATS.VIDEO_CORRELATE, false);
-    });
+    return Promise.all([
+      this.peerConnection.videoTransceiver.sender.getStats().then((res) => {
+        this.filterAndParseGetStatsResults(res, STATS.VIDEO_CORRELATE, true);
+      }),
 
-    this.peerConnection.audioTransceiver.sender.getStats().then((res) => {
-      this.filterAndParseGetStatsResults(res, STATS.AUDIO_CORRELATE, true);
-    });
+      this.peerConnection.videoTransceiver.receiver.getStats().then((res) => {
+        this.filterAndParseGetStatsResults(res, STATS.VIDEO_CORRELATE, false);
+      }),
 
-    this.peerConnection.audioTransceiver.receiver.getStats().then((res) => {
-      this.filterAndParseGetStatsResults(res, STATS.AUDIO_CORRELATE, false);
-    });
+      this.peerConnection.audioTransceiver.sender.getStats().then((res) => {
+        this.filterAndParseGetStatsResults(res, STATS.AUDIO_CORRELATE, true);
+      }),
 
-    // TODO: add checks for screen share
-    this.peerConnection.shareTransceiver.sender.getStats().then((res) => {
-      this.filterAndParseGetStatsResults(res, STATS.SHARE_CORRELATE, true);
-    });
+      this.peerConnection.audioTransceiver.receiver.getStats().then((res) => {
+        this.filterAndParseGetStatsResults(res, STATS.AUDIO_CORRELATE, false);
+      }),
 
-    this.peerConnection.shareTransceiver.receiver.getStats().then((res) => {
-      this.filterAndParseGetStatsResults(res, STATS.SHARE_CORRELATE, false);
-    });
+      // TODO: add checks for screen share
+      this.peerConnection.shareTransceiver.sender.getStats().then((res) => {
+        this.filterAndParseGetStatsResults(res, STATS.SHARE_CORRELATE, true);
+      }),
 
-    // updates the current direction of media
-    this.statsResults[STATS.AUDIO_CORRELATE].direction = this.peerConnection.audioTransceiver.currentDirection;
-    this.statsResults[STATS.VIDEO_CORRELATE].direction = this.peerConnection.videoTransceiver.currentDirection;
-    this.statsResults[STATS.SHARE_CORRELATE].direction = this.peerConnection.shareTransceiver.currentDirection;
+      this.peerConnection.shareTransceiver.receiver.getStats().then((res) => {
+        this.filterAndParseGetStatsResults(res, STATS.SHARE_CORRELATE, false);
+      }),
 
-    // Process Stats results every 5 seconds
-    this.compareLastStatsResult();
+    ]).then(() => {
+      this.statsResults[STATS.AUDIO_CORRELATE].direction = this.peerConnection.audioTransceiver.currentDirection;
+      this.statsResults[STATS.VIDEO_CORRELATE].direction = this.peerConnection.videoTransceiver.currentDirection;
+      this.statsResults[STATS.SHARE_CORRELATE].direction = this.peerConnection.shareTransceiver.currentDirection;
 
-    // Save the last results to compare with the current
-    // 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));
+      // Process Stats results every 5 seconds
+      this.compareLastStatsResult();
+
+      // Save the last results to compare with the current
+      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');
+    });
   }
 
   /**
@@ -674,6 +738,7 @@ export default class StatsAnalyzer extends EventsScope {
       this.statsResults[mediaType][sendrecvType].totalPliCount = result.pliCount;
       this.statsResults[mediaType][sendrecvType].totalPacketsSent = result.packetsSent;
       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;

package/test/integration/spec/journey.js

@@ -1,9 +1,10 @@
 /* globals navigator */
 import {assert} from '@webex/test-helper-chai';
 import {skipInNode} from '@webex/test-helper-mocha';
-import BrowserDetection from '@webex/plugin-meetings/src/common/browser-detection';
 import sinon from 'sinon';
 
+import BrowserDetection from '@webex/plugin-meetings/src/common/browser-detection';
+
 import DEFAULT_RESOLUTIONS from '../../../src/config';
 import testUtils from '../../utils/testUtils';
 
@@ -297,65 +298,6 @@ skipInNode(describe)('plugin-meetings', () => {
         assert.exists(alice.meeting.members.selfId, 'selfId not present');
       });
 
-      it('check for getStats', () => {
-        const options = {
-          useConfig: true,
-          senders: [
-            {
-              id: 'audioSend',
-              history: true,
-              correlate: 'audio', // NECESSARY KEY
-              onData: (k) => { console.log('audioSend stats data cb', k); }
-            }
-          ],
-          receivers: [
-            {
-              id: 'audioRecv',
-              history: true,
-              correlate: 'audio', // NECESSARY KEY
-              onData: (k) => { console.log('audioRecv stats data cb', k); }
-            }
-          ]
-        };
-
-        alice.meeting.getStats(options, true);
-        bob.meeting.getStats(options, true);
-
-        assert.exists(alice.meeting.getStats());
-        assert.exists(bob.meeting.getStats());
-
-        assert.exists(alice.meeting.getStats().getSender('audioSend'));
-        assert.exists(alice.meeting.getStats().getReceiver('audioRecv'));
-        assert.exists(bob.meeting.getStats().getSender('audioSend'));
-        assert.exists(bob.meeting.getStats().getReceiver('audioRecv'));
-
-        return testUtils.waitUntil(7000);
-      });
-
-      it('check populated get stats data', () => {
-        assert.ok(alice.meeting.getStats().getSender('audioSend').getHistory().get().length);
-        assert.ok(alice.meeting.getStats().getReceiver('audioRecv').getHistory().get().length);
-        assert.ok(bob.meeting.getStats().getSender('audioSend').getHistory().get().length);
-        assert.ok(bob.meeting.getStats().getReceiver('audioRecv').getHistory().get().length);
-      });
-
-      it('analyze getStats data', () => {
-        const aliceThirtySecondsData1 = alice.meeting.getStats().getSender('audioSend').getHistory().getSlice(5);
-        const analysis1 = alice.webex.meetings.getAnalyzer().analyze(aliceThirtySecondsData1, {analysisKeys: [{key: 'bytesSent', check: 'increasing', prop: 'rtpOutAudio'}]});
-        const aliceThirtySecondsData2 = alice.meeting.getStats().getReceiver('audioRecv').getHistory().getSlice(5);
-        const analysis2 = alice.webex.meetings.getAnalyzer().analyze(aliceThirtySecondsData2, {analysisKeys: [{key: 'bytesReceived', check: 'increasing', prop: 'rtpInAudio'}]});
-
-        const bobThirtySecondsData3 = bob.meeting.getStats().getSender('audioSend').getHistory().getSlice(5);
-        const analysis3 = alice.webex.meetings.getAnalyzer().analyze(bobThirtySecondsData3, {analysisKeys: [{key: 'bytesSent', check: 'increasing', prop: 'rtpOutAudio'}]});
-        const bobThirtySecondsData4 = bob.meeting.getStats().getReceiver('audioRecv').getHistory().getSlice(5);
-        const analysis4 = alice.webex.meetings.getAnalyzer().analyze(bobThirtySecondsData4, {analysisKeys: [{key: 'bytesReceived', check: 'increasing', prop: 'rtpInAudio'}]});
-
-        assert.equal(analysis1.valid, true);
-        assert.equal(analysis2.valid, true);
-        assert.equal(analysis3.valid, true);
-        assert.equal(analysis4.valid, true);
-      });
-
       it('alice Audio Mute ', () => {
         const checkEvent = (event) => !!event.delta.updated.find((member) => alice.meeting.members.selfId === member.id && member.isAudioMuted === true);
 
@@ -774,13 +716,6 @@ skipInNode(describe)('plugin-meetings', () => {
           throw e;
         }));
 
-      it('shut down get stats', () => {
-        alice.meeting.stopStats();
-        bob.meeting.stopStats();
-        assert.ok(!alice.meeting.stats);
-        assert.ok(!bob.meeting.stats);
-      });
-
       it('leave on the meeting object', () => {
         const checkInactive = (result) => result.reason === 'CALL_INACTIVE';