@webex/plugin-meetings 3.0.0-beta.32 → 3.0.0-beta.321

package/src/statsAnalyzer/mqaUtil.ts

@@ -23,7 +23,7 @@ export const getAudioReceiverMqa = ({audioReceiver, statsResults, lastMqaDataSen
   }
 
   audioReceiver.common.common.direction = statsResults[mediaType].direction;
-  audioReceiver.common.transportType = statsResults.connectionType.remote.transport[0];
+  audioReceiver.common.transportType = statsResults.connectionType.local.transport;
 
   // add rtpPacket info inside common as also for call analyzer
   audioReceiver.common.rtpPackets =
@@ -83,7 +83,7 @@ export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent, m
   }
 
   audioSender.common.common.direction = statsResults[mediaType].direction;
-  audioSender.common.transportType = statsResults.connectionType.local.transport[0];
+  audioSender.common.transportType = statsResults.connectionType.local.transport;
 
   audioSender.common.maxRemoteJitter =
     // @ts-ignore
@@ -134,9 +134,12 @@ export const getVideoReceiverMqa = ({videoReceiver, statsResults, lastMqaDataSen
   const lastPacketsReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsReceived || 0;
   const lastPacketsLost = lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsLost || 0;
   const lastBytesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesReceived || 0;
-  const lastFramesReceived = lastMqaDataSent[mediaType]?.[sendrecvType].framesReceived || 0;
-  const lastFramesDecoded = lastMqaDataSent[mediaType]?.[sendrecvType].framesDecoded || 0;
-  const lastFramesDropped = lastMqaDataSent[mediaType]?.[sendrecvType].framesDropped || 0;
+  const lastFramesReceived =
+    lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].framesReceived || 0;
+  const lastFramesDecoded =
+    lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].framesDecoded || 0;
+  const lastFramesDropped =
+    lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].framesDropped || 0;
   const lastKeyFramesDecoded = lastMqaDataSent[mediaType]?.[sendrecvType].keyFramesDecoded || 0;
   const lastPliCount = lastMqaDataSent[mediaType]?.[sendrecvType].totalPliCount || 0;
 
@@ -146,7 +149,8 @@ export const getVideoReceiverMqa = ({videoReceiver, statsResults, lastMqaDataSen
   }
 
   videoReceiver.common.common.direction = statsResults[mediaType].direction;
-  videoReceiver.common.transportType = statsResults.connectionType.remote.transport[0];
+  videoReceiver.common.transportType = statsResults.connectionType.local.transport;
+
   // collect the packets received for the last min
   videoReceiver.common.rtpPackets =
     statsResults[mediaType][sendrecvType].totalPacketsReceived - lastPacketsReceived || 0;
@@ -189,22 +193,21 @@ export const getVideoReceiverMqa = ({videoReceiver, statsResults, lastMqaDataSen
   const totalFrameDecodedInaMin =
     statsResults.resolutions[mediaType][sendrecvType].framesDecoded - lastFramesDecoded;
 
-  videoReceiver.streams[0].common.receivedFrameRate = totalFrameReceivedInaMin
-    ? (totalFrameReceivedInaMin * 100) / 60
-    : 0;
-  videoReceiver.streams[0].common.renderedFrameRate = totalFrameDecodedInaMin
-    ? (totalFrameDecodedInaMin * 100) / 60
-    : 0;
+  videoReceiver.streams[0].common.receivedFrameRate = Math.round(
+    totalFrameReceivedInaMin ? totalFrameReceivedInaMin / 60 : 0
+  );
+  videoReceiver.streams[0].common.renderedFrameRate = Math.round(
+    totalFrameDecodedInaMin ? totalFrameDecodedInaMin / 60 : 0
+  );
 
   videoReceiver.streams[0].common.framesDropped =
     statsResults.resolutions[mediaType][sendrecvType].framesDropped - lastFramesDropped;
   videoReceiver.streams[0].receivedHeight =
-    statsResults.resolutions[mediaType][sendrecvType].height;
-  videoReceiver.streams[0].receivedWidth = statsResults.resolutions[mediaType][sendrecvType].width;
+    statsResults.resolutions[mediaType][sendrecvType].height || 0;
+  videoReceiver.streams[0].receivedWidth =
+    statsResults.resolutions[mediaType][sendrecvType].width || 0;
   videoReceiver.streams[0].receivedFrameSize =
-    (statsResults.resolutions[mediaType][sendrecvType].height *
-      statsResults.resolutions[mediaType][sendrecvType].height) /
-    256;
+    (videoReceiver.streams[0].receivedHeight * videoReceiver.streams[0].receivedWidth) / 256;
 
   videoReceiver.streams[0].receivedKeyFrames =
     statsResults[mediaType][sendrecvType].keyFramesDecoded - lastKeyFramesDecoded || 0;
@@ -220,16 +223,16 @@ export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, m
     lastMqaDataSent[mediaType]?.[sendrecvType].totalPacketsLostOnReceiver || 0;
   const lastBytesSent = lastMqaDataSent[mediaType]?.[sendrecvType].totalBytesSent || 0;
   const lastKeyFramesEncoded =
-    lastMqaDataSent[mediaType]?.[sendrecvType].totalKeyFramesEncoded || 0;
+    lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].totalKeyFramesEncoded || 0;
   const lastFirCount = lastMqaDataSent[mediaType]?.[sendrecvType].totalFirCount || 0;
-  const lastFramesSent = lastMqaDataSent[mediaType]?.[sendrecvType].framesSent || 0;
+  const lastFramesSent = lastMqaDataSent.resolutions[mediaType]?.[sendrecvType].framesSent || 0;
   const {csi} = statsResults[mediaType];
   if (csi && !videoSender.streams[0].common.csi.includes(csi)) {
     videoSender.streams[0].common.csi.push(csi);
   }
 
   videoSender.common.common.direction = statsResults[mediaType].direction;
-  videoSender.common.transportType = statsResults.connectionType.local.transport[0];
+  videoSender.common.transportType = statsResults.connectionType.local.transport;
 
   // @ts-ignore
   videoSender.common.maxRemoteJitter =
@@ -280,14 +283,13 @@ export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, m
   const totalFrameSentInaMin =
     statsResults.resolutions[mediaType][sendrecvType].framesSent - (lastFramesSent || 0);
 
-  videoSender.streams[0].common.transmittedFrameRate = totalFrameSentInaMin
-    ? (totalFrameSentInaMin * 100) / 60
-    : 0;
+  videoSender.streams[0].common.transmittedFrameRate = Math.round(
+    totalFrameSentInaMin ? totalFrameSentInaMin / 60 : 0
+  );
   videoSender.streams[0].transmittedHeight =
-    statsResults.resolutions[mediaType][sendrecvType].height;
-  videoSender.streams[0].transmittedWidth = statsResults.resolutions[mediaType][sendrecvType].width;
+    statsResults.resolutions[mediaType][sendrecvType].height || 0;
+  videoSender.streams[0].transmittedWidth =
+    statsResults.resolutions[mediaType][sendrecvType].width || 0;
   videoSender.streams[0].transmittedFrameSize =
-    (statsResults.resolutions[mediaType][sendrecvType].height *
-      statsResults.resolutions[mediaType][sendrecvType].width) /
-    254;
+    (videoSender.streams[0].transmittedHeight * videoSender.streams[0].transmittedWidth) / 256;
 };

package/src/webinar/collection.ts

@@ -0,0 +1,31 @@
+/*!
+ * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {MEETINGS} from '../constants';
+
+class WebinarCollection {
+  webinarInfo: any;
+
+  namespace = MEETINGS;
+
+  mainIndex = 'sessionId';
+
+  constructor() {
+    this.webinarInfo = {};
+  }
+
+  set(id, info) {
+    this.webinarInfo[id] = info;
+  }
+
+  /**
+   * @param {String} id
+   * @returns {Member}
+   */
+  get(id: string) {
+    return this.webinarInfo[id];
+  }
+}
+
+export default WebinarCollection;

package/src/webinar/index.ts

@@ -0,0 +1,62 @@
+/*!
+ * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
+ */
+import {WebexPlugin} from '@webex/webex-core';
+import {MEETINGS} from '../constants';
+
+import WebinarCollection from './collection';
+
+/**
+ * @class Webinar
+ */
+const Webinar = WebexPlugin.extend({
+  namespace: MEETINGS,
+  collections: {
+    webinar: WebinarCollection,
+  },
+
+  props: {
+    locusUrl: 'string', // appears current webinar's locus url
+    webcastUrl: 'string', // current webinar's webcast url
+    webinarAttendeesSearchingUrl: 'string', // current webinarAttendeesSearching url
+    canManageWebcast: 'boolean', // appears the ability to manage webcast
+  },
+
+  /**
+   * Update the current locus url of the webinar
+   * @param {string} locusUrl // locus url
+   * @returns {void}
+   */
+  locusUrlUpdate(locusUrl) {
+    this.set('locusUrl', locusUrl);
+  },
+
+  /**
+   * Update the current webcast url of the meeting
+   * @param {string} webcastUrl // webcast url
+   * @returns {void}
+   */
+  webcastUrlUpdate(webcastUrl) {
+    this.set('webcastUrl', webcastUrl);
+  },
+
+  /**
+   * Update the current webinarAttendeesSearching url of the meeting
+   * @param {string} webinarAttendeesSearchingUrl // webinarAttendeesSearching url
+   * @returns {void}
+   */
+  webinarAttendeesSearchingUrlUpdate(webinarAttendeesSearchingUrl) {
+    this.set('webinarAttendeesSearchingUrl', webinarAttendeesSearchingUrl);
+  },
+
+  /**
+   * Update whether self has capability to manage start/stop webcast (only host can manage it)
+   * @param {boolean} canManageWebcast
+   * @returns {void}
+   */
+  updateCanManageWebcast(canManageWebcast) {
+    this.set('canManageWebcast', canManageWebcast);
+  },
+});
+
+export default Webinar;

package/test/integration/spec/converged-space-meetings.js

@@ -3,13 +3,30 @@ import 'jsdom-global/register';
 import {assert} from '@webex/test-helper-chai';
 import {skipInNode} from '@webex/test-helper-mocha';
 import BrowserDetection from '@webex/plugin-meetings/dist/common/browser-detection';
+import {createCameraStream, createMicrophoneStream} from '@webex/plugin-meetings';
 
 import {MEDIA_SERVERS} from '../../utils/constants';
 import testUtils from '../../utils/testUtils';
+import integrationTestUtils from '../../utils/integrationTestUtils';
 import webexTestUsers from '../../utils/webex-test-users';
 
 config();
 
+const localTracks = {
+  alice: {
+    microphone: undefined,
+    camera: undefined,
+  },
+  bob: {
+    microphone: undefined,
+    camera: undefined,
+  },
+  chris: {
+    microphone: undefined,
+    camera: undefined,
+  },
+};
+
 skipInNode(describe)('plugin-meetings', () => {
   const {isBrowser} = BrowserDetection();
 
@@ -135,6 +152,17 @@ skipInNode(describe)('plugin-meetings', () => {
         assert.exists(chris.meeting.joinedWith);
       });
 
+      it('users "alice", "bob", and "chris" create local tracks', async () => {
+        localTracks.alice.microphone = await createMicrophoneStream();
+        localTracks.alice.camera = await createCameraStream();
+
+        localTracks.bob.microphone = await createMicrophoneStream();
+        localTracks.bob.camera = await createCameraStream();
+
+        localTracks.chris.microphone = await createMicrophoneStream();
+        localTracks.chris.camera = await createCameraStream();
+      });
+
       it('users "alice", "bob", and "chris" add media', async () => {
         mediaReadyListener = testUtils.waitForEvents([
           {scope: alice.meeting, event: 'media:negotiated'},
@@ -142,9 +170,9 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: chris.meeting, event: 'media:negotiated'},
         ]);
 
-        const addMediaAlice = testUtils.addMedia(alice, {expectedMediaReadyTypes: ['local']});
-        const addMediaBob = testUtils.addMedia(bob, {expectedMediaReadyTypes: ['local']});
-        const addMediaChris = testUtils.addMedia(chris, {expectedMediaReadyTypes: ['local']});
+        const addMediaAlice = integrationTestUtils.addMedia(alice, {multistream: true, microphone: localTracks.alice.microphone, camera: localTracks.alice.camera});
+        const addMediaBob = integrationTestUtils.addMedia(bob, {multistream: true, microphone: localTracks.bob.microphone, camera: localTracks.bob.camera});
+        const addMediaChris = integrationTestUtils.addMedia(chris, {multistream: true, microphone: localTracks.chris.microphone, camera: localTracks.chris.camera});
 
         await addMediaAlice;
         await addMediaBob;
@@ -171,6 +199,35 @@ skipInNode(describe)('plugin-meetings', () => {
         assert.equal(bob.meeting.mediaProperties.webrtcMediaConnection.mediaServer, MEDIA_SERVERS.HOMER);
         assert.equal(chris.meeting.mediaProperties.webrtcMediaConnection.mediaServer, MEDIA_SERVERS.HOMER);
       });
+
+      it('users "alice", "bob", and "chris" stop their local tracks', () => {
+        if (localTracks.alice.microphone) {
+          localTracks.alice.microphone.stop();
+          localTracks.alice.microphone = undefined;
+        }
+        if (localTracks.alice.camera) {
+          localTracks.alice.camera.stop();
+          localTracks.alice.camera = undefined;
+        }
+
+        if (localTracks.bob.microphone) {
+          localTracks.bob.microphone.stop();
+          localTracks.bob.microphone = undefined;
+        }
+        if (localTracks.bob.camera) {
+          localTracks.bob.camera.stop();
+          localTracks.bob.camera = undefined;
+        }
+
+        if (localTracks.chris.microphone) {
+          localTracks.chris.microphone.stop();
+          localTracks.chris.microphone = undefined;
+        }
+        if (localTracks.chris.camera) {
+          localTracks.chris.camera.stop();
+          localTracks.chris.camera = undefined;
+        }
+      });
     });
   }
 });