@webex/plugin-meetings 3.1.0-next.2 → 3.1.0-next.21

package/src/statsAnalyzer/index.ts

@@ -998,12 +998,13 @@ export class StatsAnalyzer extends EventsScope {
         result.qualityLimitationReason;
       this.statsResults[mediaType][sendrecvType].qualityLimitationResolutionChanges =
         result.qualityLimitationResolutionChanges;
-      this.statsResults[mediaType][sendrecvType].retransmittedPacketsSent =
+      this.statsResults[mediaType][sendrecvType].totalRtxPacketsSent =
         result.retransmittedPacketsSent;
+      this.statsResults[mediaType][sendrecvType].totalRtxBytesSent = result.retransmittedBytesSent;
       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].requestedBitrate = result.requestedBitrate;
+      this.statsResults[mediaType][sendrecvType].requestedFrameSize = result.requestedFrameSize;
     }
   }
 
@@ -1116,6 +1117,8 @@ export class StatsAnalyzer extends EventsScope {
 
       this.statsResults[mediaType][sendrecvType].lastPacketReceivedTimestamp =
         result.lastPacketReceivedTimestamp;
+      this.statsResults[mediaType][sendrecvType].requestedBitrate = result.requestedBitrate;
+      this.statsResults[mediaType][sendrecvType].requestedFrameSize = result.requestedFrameSize;
 
       // From Thin
       this.statsResults[mediaType][sendrecvType].totalNackCount = result.nackCount;
@@ -1132,6 +1135,10 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[mediaType][sendrecvType].fecPacketsReceived = result.fecPacketsReceived;
       this.statsResults[mediaType][sendrecvType].totalBytesReceived = result.bytesReceived;
       this.statsResults[mediaType][sendrecvType].headerBytesReceived = result.headerBytesReceived;
+      this.statsResults[mediaType][sendrecvType].totalRtxPacketsReceived =
+        result.retransmittedPacketsReceived;
+      this.statsResults[mediaType][sendrecvType].totalRtxBytesReceived =
+        result.retransmittedBytesReceived;
 
       this.statsResults[mediaType][sendrecvType].meanRtpJitter.push(result.jitter);
 

package/src/statsAnalyzer/mqaUtil.ts

@@ -216,6 +216,8 @@ export const getAudioSenderStreamMqa = ({
     statsResults[mediaType][sendrecvType].totalKeyFramesEncoded - lastFramesEncoded || 0;
   audioSenderStream.requestedKeyFrames =
     statsResults[mediaType][sendrecvType].totalFirCount - lastFirCount || 0;
+
+  audioSenderStream.requestedBitrate = statsResults[mediaType][sendrecvType].requestedBitrate || 0;
 };
 
 export const getVideoReceiverMqa = ({
@@ -235,10 +237,16 @@ export const getVideoReceiverMqa = ({
   const lastPacketsLost = getLastTotalValue('totalPacketsLost');
   const lastBytesReceived = getLastTotalValue('totalBytesReceived');
 
+  const lastRtxPacketsReceived = getLastTotalValue('totalRtxPacketsReceived');
+  const lastRtxBytesReceived = getLastTotalValue('totalRtxBytesReceived');
+
   const packetsLost = getTotalValue('totalPacketsLost');
   const totalPacketsReceived = getTotalValue('totalPacketsReceived');
   const totalBytesReceived = getTotalValue('totalBytesReceived');
 
+  const totalRtxPacketsReceived = getTotalValue('totalRtxPacketsReceived');
+  const totalRtxBytesReceived = getTotalValue('totalRtxBytesReceived');
+
   const meanRemoteJitter = Object.keys(statsResults)
     .filter((mt) => mt.includes(baseMediaType))
     .reduce((acc, mt) => acc.concat(statsResults[mt][sendrecvType].meanRemoteJitter), []);
@@ -264,10 +272,15 @@ export const getVideoReceiverMqa = ({
 
   // Calculate the outgoing bitrate
   const totalBytesReceivedInaMin = totalBytesReceived - lastBytesReceived;
+  const totalRtxBytesReceivedInaMin = totalRtxBytesReceived - lastRtxBytesReceived;
 
   videoReceiver.common.rtpBitrate = totalBytesReceivedInaMin
     ? (totalBytesReceivedInaMin * 8) / 60
     : 0;
+  videoReceiver.common.rtxPackets = totalRtxPacketsReceived - lastRtxPacketsReceived;
+  videoReceiver.common.rtxBitrate = totalRtxBytesReceivedInaMin
+    ? (totalRtxBytesReceivedInaMin * 8) / 60
+    : 0;
 };
 
 export const getVideoReceiverStreamMqa = ({
@@ -347,11 +360,15 @@ export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, b
   const lastPacketsSent = getLastTotalValue('totalPacketsSent');
   const lastBytesSent = getLastTotalValue('totalBytesSent');
   const lastPacketsLostTotal = getLastTotalValue('totalPacketsLostOnReceiver');
+  const lastRtxPacketsSent = getLastTotalValue('totalRtxPacketsSent');
+  const lastRtxBytesSent = getLastTotalValue('totalRtxBytesSent');
 
   const totalPacketsLostOnReceiver = getTotalValue('totalPacketsLostOnReceiver');
   const totalPacketsSent = getTotalValue('totalPacketsSent');
   const totalBytesSent = getTotalValue('totalBytesSent');
   const availableOutgoingBitrate = getTotalValue('availableOutgoingBitrate');
+  const totalRtxPacketsSent = getTotalValue('totalRtxPacketsSent');
+  const totalRtxBytesSent = getTotalValue('totalRtxBytesSent');
 
   videoSender.common.common.direction =
     statsResults[Object.keys(statsResults).find((mediaType) => mediaType.includes(baseMediaType))]
@@ -387,8 +404,11 @@ export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, b
 
   // Calculate the outgoing bitrate
   const totalBytesSentInaMin = totalBytesSent - lastBytesSent;
+  const totalRtxBytesSentInaMin = totalRtxBytesSent - lastRtxBytesSent;
 
   videoSender.common.rtpBitrate = totalBytesSentInaMin ? (totalBytesSentInaMin * 8) / 60 : 0;
+  videoSender.common.rtxPackets = totalRtxPacketsSent - lastRtxPacketsSent;
+  videoSender.common.rtxBitrate = totalRtxBytesSentInaMin ? (totalRtxBytesSentInaMin * 8) / 60 : 0;
 };
 
 export const getVideoSenderStreamMqa = ({
@@ -437,4 +457,7 @@ export const getVideoSenderStreamMqa = ({
   videoSenderStream.transmittedWidth = statsResults[mediaType][sendrecvType].width || 0;
   videoSenderStream.transmittedFrameSize =
     (videoSenderStream.transmittedHeight * videoSenderStream.transmittedWidth) / 256;
+  videoSenderStream.requestedBitrate = statsResults[mediaType][sendrecvType].requestedBitrate || 0;
+  videoSenderStream.requestedFrameSize =
+    statsResults[mediaType][sendrecvType].requestedFrameSize || 0;
 };

package/test/unit/spec/locus-info/controlsUtils.js

@@ -269,6 +269,26 @@ describe('plugin-meetings', () => {
         assert.equal(updates.hasInterpretationChanged, false);
       });
 
+      it('returns hasManualCaptionChanged = true when it has changed', () => {
+        const newControls = {
+          manualCaptionControl: {enabled: false},
+        };
+
+        const {updates} = ControlsUtils.getControls({manualCaptionControl: {enabled: true}}, newControls);
+
+        assert.equal(updates.hasManualCaptionChanged, true);
+      });
+
+      it('returns hasManualCaptionChanged = false when it has not changed', () => {
+        const newControls = {
+          manualCaptionControl: {enabled: true},
+        };
+
+        const {updates} = ControlsUtils.getControls({manualCaptionControl: {enabled: true}}, newControls);
+
+        assert.equal(updates.hasManualCaptionChanged, false);
+      });
+
       describe('videoEnabled', () => {
         const testVideoEnabled = (oldControls, newControls, updatedProperty) => {
           const result = ControlsUtils.getControls(oldControls, newControls);

package/test/unit/spec/locus-info/index.js

@@ -467,6 +467,27 @@ describe('plugin-meetings', () => {
         );
       });
 
+      it('should update the manual caption state', () => {
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.controls = {
+          manualCaptionControl: {enabled: false},
+        };
+
+        locusInfo.updateControls({manualCaptionControl: { enabled: true, }});
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateControls',
+          },
+          LOCUSINFO.EVENTS.CONTROLS_MEETING_MANUAL_CAPTION_UPDATED,
+          {
+            enabled: true,
+          }
+        );
+      });
+
       it('should update the meetingContainerURL from null', () => {
         locusInfo.controls = {
           meetingContainer: {meetingContainerUrl: null},

package/test/unit/spec/media/properties.ts

@@ -54,189 +54,194 @@ describe('MediaProperties', () => {
     });
   });
 
-  describe('getCurrentConnectionType', () => {
-    it('calls waitForMediaConnectionConnected', async () => {
-      const spy = sinon.stub(mediaProperties, 'waitForMediaConnectionConnected');
+  describe('getCurrentConnectionInfo', () => {
+    it('handles the case when getStats() fails', async () => {
+      mockMC.getStats.rejects(new Error());
 
-      await mediaProperties.getCurrentConnectionType();
+      const {connectionType, selectedCandidatePairChanges, numTransports} =
+        await mediaProperties.getCurrentConnectionInfo();
 
-      assert.calledOnce(spy);
+      assert.equal(connectionType, 'unknown');
+      assert.equal(selectedCandidatePairChanges, -1);
+      assert.equal(numTransports, 0);
     });
-    it('calls getStats() only after waitForMediaConnectionConnected resolves', async () => {
-      const waitForMediaConnectionConnectedResult = new Defer();
-
-      const waitForMediaConnectionConnectedStub = sinon
-        .stub(mediaProperties, 'waitForMediaConnectionConnected')
-        .returns(waitForMediaConnectionConnectedResult.promise);
-
-      const result = mediaProperties.getCurrentConnectionType();
 
-      await testUtils.flushPromises();
+    describe('selectedCandidatePairChanges and numTransports', () => {
+      it('returns correct values when getStats() returns no transport stats at all', async () => {
+        mockMC.getStats.resolves([{type: 'something', id: '1234'}]);
 
-      assert.called(waitForMediaConnectionConnectedStub);
-      assert.notCalled(mockMC.getStats);
+        const {selectedCandidatePairChanges, numTransports} =
+          await mediaProperties.getCurrentConnectionInfo();
 
-      waitForMediaConnectionConnectedResult.resolve();
-      await testUtils.flushPromises();
+        assert.equal(selectedCandidatePairChanges, -1);
+        assert.equal(numTransports, 0);
+      });
 
-      assert.called(mockMC.getStats);
-      await result;
-    });
-    it('rejects if waitForMediaConnectionConnected rejects', async () => {
-      const waitForMediaConnectionConnectedResult = new Defer();
+      it('returns correct values when getStats() returns transport stats without selectedCandidatePairChanges', async () => {
+        mockMC.getStats.resolves([{type: 'transport', id: '1234'}]);
 
-      const waitForMediaConnectionConnectedStub = sinon
-        .stub(mediaProperties, 'waitForMediaConnectionConnected')
-        .returns(waitForMediaConnectionConnectedResult.promise);
+        const {selectedCandidatePairChanges, numTransports} =
+          await mediaProperties.getCurrentConnectionInfo();
 
-      const result = mediaProperties.getCurrentConnectionType();
+        assert.equal(selectedCandidatePairChanges, -1);
+        assert.equal(numTransports, 1);
+      });
 
-      await testUtils.flushPromises();
+      it('returns correct values when getStats() returns transport stats with selectedCandidatePairChanges', async () => {
+        mockMC.getStats.resolves([
+          {type: 'transport', id: '1234', selectedCandidatePairChanges: 13},
+        ]);
 
-      assert.called(waitForMediaConnectionConnectedStub);
+        const {selectedCandidatePairChanges, numTransports} =
+          await mediaProperties.getCurrentConnectionInfo();
 
-      waitForMediaConnectionConnectedResult.reject(new Error('fake error'));
-      await testUtils.flushPromises();
+        assert.equal(selectedCandidatePairChanges, 13);
+        assert.equal(numTransports, 1);
+      });
 
-      assert.notCalled(mockMC.getStats);
+      it('returns correct values when getStats() returns multiple transport stats', async () => {
+        mockMC.getStats.resolves([
+          {type: 'transport', id: '1', selectedCandidatePairChanges: 11},
+          {type: 'transport', id: '2', selectedCandidatePairChanges: 12},
+        ]);
 
-      await assert.isRejected(result);
-    });
-    it('returns "unknown" if getStats() fails', async () => {
-      mockMC.getStats.rejects(new Error());
+        const {selectedCandidatePairChanges, numTransports} =
+          await mediaProperties.getCurrentConnectionInfo();
 
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'unknown');
+        assert.equal(selectedCandidatePairChanges, 11); // we expect stats from the first transport to be returned
+        assert.equal(numTransports, 2);
+      });
     });
+    describe('connectionType', () => {
+      it('returns "unknown" if getStats() returns no candidate pairs', async () => {
+        mockMC.getStats.resolves([{type: 'something', id: '1234'}]);
 
-    it('returns "unknown" if getStats() returns no candidate pairs', async () => {
-      mockMC.getStats.resolves([{type: 'something', id: '1234'}]);
+        const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(connectionType, 'unknown');
+      });
 
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'unknown');
-    });
+      it('returns "unknown" if getStats() returns no successful candidate pair', async () => {
+        mockMC.getStats.resolves([{type: 'candidate-pair', id: '1234', state: 'inprogress'}]);
 
-    it('returns "unknown" if getStats() returns no successful candidate pair', async () => {
-      mockMC.getStats.resolves([{type: 'candidate-pair', id: '1234', state: 'inprogress'}]);
+        const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(connectionType, 'unknown');
+      });
 
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'unknown');
-    });
+      it('returns "unknown" if getStats() returns a successful candidate pair but local candidate is missing', async () => {
+        mockMC.getStats.resolves([
+          {type: 'candidate-pair', id: '1234', state: 'succeeded', localCandidateId: 'wrong id'},
+        ]);
 
-    it('returns "unknown" if getStats() returns a successful candidate pair but local candidate is missing', async () => {
-      mockMC.getStats.resolves([
-        {type: 'candidate-pair', id: '1234', state: 'succeeded', localCandidateId: 'wrong id'},
-      ]);
+        const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(connectionType, 'unknown');
+      });
 
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'unknown');
-    });
+      it('returns "UDP" if getStats() returns a successful candidate pair with udp local candidate', async () => {
+        mockMC.getStats.resolves([
+          {
+            type: 'candidate-pair',
+            id: 'some candidate pair id',
+            state: 'succeeded',
+            localCandidateId: 'local candidate id',
+          },
+          {type: 'local-candidate', id: 'some other candidate id', protocol: 'tcp'},
+          {type: 'local-candidate', id: 'local candidate id', protocol: 'udp'},
+        ]);
 
-    it('returns "UDP" if getStats() returns a successful candidate pair with udp local candidate', async () => {
-      mockMC.getStats.resolves([
-        {
-          type: 'candidate-pair',
-          id: 'some candidate pair id',
-          state: 'succeeded',
-          localCandidateId: 'local candidate id',
-        },
-        {type: 'local-candidate', id: 'some other candidate id', protocol: 'tcp'},
-        {type: 'local-candidate', id: 'local candidate id', protocol: 'udp'},
-      ]);
-
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'UDP');
-    });
+        const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(connectionType, 'UDP');
+      });
 
-    it('returns "TCP" if getStats() returns a successful candidate pair with tcp local candidate', async () => {
-      mockMC.getStats.resolves([
-        {
-          type: 'candidate-pair',
-          id: 'some candidate pair id',
-          state: 'succeeded',
-          localCandidateId: 'some candidate id',
-        },
-        {type: 'local-candidate', id: 'some other candidate id', protocol: 'udp'},
-        {type: 'local-candidate', id: 'some candidate id', protocol: 'tcp'},
-      ]);
-
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'TCP');
-    });
+      it('returns "TCP" if getStats() returns a successful candidate pair with tcp local candidate', async () => {
+        mockMC.getStats.resolves([
+          {
+            type: 'candidate-pair',
+            id: 'some candidate pair id',
+            state: 'succeeded',
+            localCandidateId: 'some candidate id',
+          },
+          {type: 'local-candidate', id: 'some other candidate id', protocol: 'udp'},
+          {type: 'local-candidate', id: 'some candidate id', protocol: 'tcp'},
+        ]);
 
-    [
-      {relayProtocol: 'tls', expectedConnectionType: 'TURN-TLS'},
-      {relayProtocol: 'tcp', expectedConnectionType: 'TURN-TCP'},
-      {relayProtocol: 'udp', expectedConnectionType: 'TURN-UDP'},
-    ].forEach(({relayProtocol, expectedConnectionType}) =>
-      it(`returns "${expectedConnectionType}" if getStats() returns a successful candidate pair with a local candidate with relayProtocol=${relayProtocol}`, async () => {
+        const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(connectionType, 'TCP');
+      });
+
+      [
+        {relayProtocol: 'tls', expectedConnectionType: 'TURN-TLS'},
+        {relayProtocol: 'tcp', expectedConnectionType: 'TURN-TCP'},
+        {relayProtocol: 'udp', expectedConnectionType: 'TURN-UDP'},
+      ].forEach(({relayProtocol, expectedConnectionType}) =>
+        it(`returns "${expectedConnectionType}" if getStats() returns a successful candidate pair with a local candidate with relayProtocol=${relayProtocol}`, async () => {
+          mockMC.getStats.resolves([
+            {
+              type: 'candidate-pair',
+              id: 'some candidate pair id',
+              state: 'succeeded',
+              localCandidateId: 'selected candidate id',
+            },
+            {
+              type: 'candidate-pair',
+              id: 'some other candidate pair id',
+              state: 'failed',
+              localCandidateId: 'some other candidate id 1',
+            },
+            {type: 'local-candidate', id: 'some other candidate id 1', protocol: 'udp'},
+            {type: 'local-candidate', id: 'some other candidate id 2', protocol: 'tcp'},
+            {
+              type: 'local-candidate',
+              id: 'selected candidate id',
+              protocol: 'udp',
+              relayProtocol,
+            },
+          ]);
+
+          const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+          assert.equal(connectionType, expectedConnectionType);
+        })
+      );
+
+      it('returns connection type of the first successful candidate pair', async () => {
+        // in real life this will never happen and all active candidate pairs will have same transport,
+        // but here we're simulating a situation where they have different transports and just checking
+        // that the code still works and just returns the first one
         mockMC.getStats.resolves([
+          {
+            type: 'inbound-rtp',
+            id: 'whatever',
+          },
           {
             type: 'candidate-pair',
             id: 'some candidate pair id',
             state: 'succeeded',
-            localCandidateId: 'selected candidate id',
+            localCandidateId: '1st selected candidate id',
           },
           {
             type: 'candidate-pair',
             id: 'some other candidate pair id',
-            state: 'failed',
-            localCandidateId: 'some other candidate id 1',
+            state: 'succeeded',
+            localCandidateId: '2nd selected candidate id',
           },
           {type: 'local-candidate', id: 'some other candidate id 1', protocol: 'udp'},
           {type: 'local-candidate', id: 'some other candidate id 2', protocol: 'tcp'},
           {
             type: 'local-candidate',
-            id: 'selected candidate id',
+            id: '1st selected candidate id',
+            protocol: 'udp',
+            relayProtocol: 'tls',
+          },
+          {
+            type: 'local-candidate',
+            id: '2nd selected candidate id',
             protocol: 'udp',
-            relayProtocol,
+            relayProtocol: 'tcp',
           },
         ]);
 
-        const connectionType = await mediaProperties.getCurrentConnectionType();
-        assert.equal(connectionType, expectedConnectionType);
-      })
-    );
-
-    it('returns connection type of the first successful candidate pair', async () => {
-      // in real life this will never happen and all active candidate pairs will have same transport,
-      // but here we're simulating a situation where they have different transports and just checking
-      // that the code still works and just returns the first one
-      mockMC.getStats.resolves([
-        {
-          type: 'inbound-rtp',
-          id: 'whatever',
-        },
-        {
-          type: 'candidate-pair',
-          id: 'some candidate pair id',
-          state: 'succeeded',
-          localCandidateId: '1st selected candidate id',
-        },
-        {
-          type: 'candidate-pair',
-          id: 'some other candidate pair id',
-          state: 'succeeded',
-          localCandidateId: '2nd selected candidate id',
-        },
-        {type: 'local-candidate', id: 'some other candidate id 1', protocol: 'udp'},
-        {type: 'local-candidate', id: 'some other candidate id 2', protocol: 'tcp'},
-        {
-          type: 'local-candidate',
-          id: '1st selected candidate id',
-          protocol: 'udp',
-          relayProtocol: 'tls',
-        },
-        {
-          type: 'local-candidate',
-          id: '2nd selected candidate id',
-          protocol: 'udp',
-          relayProtocol: 'tcp',
-        },
-      ]);
-
-      const connectionType = await mediaProperties.getCurrentConnectionType();
-      assert.equal(connectionType, 'TURN-TLS');
+        const {connectionType} = await mediaProperties.getCurrentConnectionInfo();
+        assert.equal(connectionType, 'TURN-TLS');
+      });
     });
   });
 });

package/test/unit/spec/meeting/in-meeting-actions.ts

@@ -30,6 +30,9 @@ describe('plugin-meetings', () => {
         canStartTranscribing: null,
         canStopTranscribing: null,
         isClosedCaptionActive: null,
+        canStartManualCaption: null,
+        canStopManualCaption: null,
+        isManualCaptionActive: null,
         isSaveTranscriptsEnabled: null,
         isWebexAssistantActive: null,
         canViewCaptionPanel: null,
@@ -110,6 +113,9 @@ describe('plugin-meetings', () => {
       'canEnableClosedCaption',
       'canStopTranscribing',
       'isClosedCaptionActive',
+      'canStartManualCaption',
+      'canStopManualCaption',
+      'isManualCaptionActive',
       'isSaveTranscriptsEnabled',
       'isWebexAssistantActive',
       'canViewCaptionPanel',