@webex/plugin-meetings 3.0.0-bnr.4 → 3.0.0-stream-classes.1

package/src/roap/request.ts

@@ -1,11 +1,9 @@
-/* global window */
 // @ts-ignore
 import {StatelessWebexPlugin} from '@webex/webex-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
-import {MEDIA, HTTP_VERBS, REACHABILITY} from '../constants';
-import Metrics from '../metrics';
-import {eventType} from '../metrics/config';
+import {IP_VERSION, REACHABILITY} from '../constants';
+import {LocusMediaRequest} from '../meeting/locusMediaRequest';
 
 /**
  * @class RoapRequest
@@ -64,72 +62,64 @@ export default class RoapRequest extends StatelessWebexPlugin {
    * @param {String} options.locusSelfUrl
    * @param {String} options.mediaId
    * @param {String} options.correlationId
-   * @param {Boolean} options.audioMuted
-   * @param {Boolean} options.videoMuted
    * @param {String} options.meetingId
-   * @param {Boolean} options.preferTranscoding
    * @returns {Promise} returns the response/failure of the request
    */
   async sendRoap(options: {
     roapMessage: any;
     locusSelfUrl: string;
     mediaId: string;
-    correlationId: string;
-    audioMuted: boolean;
-    videoMuted: boolean;
     meetingId: string;
-    preferTranscoding?: boolean;
+    ipVersion: IP_VERSION;
+    locusMediaRequest?: LocusMediaRequest;
   }) {
-    const {roapMessage, locusSelfUrl, mediaId, correlationId, meetingId} = options;
+    const {roapMessage, locusSelfUrl, mediaId, meetingId, locusMediaRequest, ipVersion} = options;
 
     if (!mediaId) {
-      LoggerProxy.logger.info('Roap:request#sendRoap --> Race Condition /call mediaID not present');
+      LoggerProxy.logger.info('Roap:request#sendRoap --> sending empty mediaID');
     }
 
+    if (!locusMediaRequest) {
+      LoggerProxy.logger.warn(
+        'Roap:request#sendRoap --> locusMediaRequest unavailable, not sending roap'
+      );
+
+      return Promise.reject(new Error('sendRoap called when locusMediaRequest is undefined'));
+    }
     const {localSdp: localSdpWithReachabilityData, joinCookie} = await this.attachReachabilityData({
       roapMessage,
-      // eslint-disable-next-line no-warning-comments
-      // TODO: check whats the need for video and audiomute
-      audioMuted: !!options.audioMuted,
-      videoMuted: !!options.videoMuted,
     });
 
-    const mediaUrl = `${locusSelfUrl}/${MEDIA}`;
-    // @ts-ignore
-    const deviceUrl = this.webex.internal.device.url;
-
     LoggerProxy.logger.info(
-      `Roap:request#sendRoap --> ${mediaUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
+      `Roap:request#sendRoap --> ${locusSelfUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
     );
 
-    Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
-
     // @ts-ignore
-    return this.request({
-      uri: mediaUrl,
-      method: HTTP_VERBS.PUT,
-      body: {
-        device: {
-          url: deviceUrl,
-          // @ts-ignore
-          deviceType: this.config.meetings.deviceType,
-        },
-        correlationId,
-        localMedias: [
-          {
-            localSdp: JSON.stringify(localSdpWithReachabilityData),
-            mediaId: options.mediaId,
-          },
-        ],
-        clientMediaPreferences: {
-          preferTranscoding: options.preferTranscoding ?? true,
-          joinCookie,
-        },
+    this.webex.internal.newMetrics.submitClientEvent({
+      name: 'client.locus.media.request',
+      options: {
+        meetingId,
       },
-    })
-      .then((res) => {
-        Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
+    });
 
+    return locusMediaRequest
+      .send({
+        type: 'RoapMessage',
+        selfUrl: locusSelfUrl,
+        joinCookie,
+        mediaId,
+        roapMessage,
+        reachability: localSdpWithReachabilityData.reachability,
+        ipVersion,
+      })
+      .then((res) => {
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.media.response',
+          options: {
+            meetingId,
+          },
+        });
         // always it will be the first mediaConnection Object
         const mediaConnections =
           res.body.mediaConnections &&
@@ -153,10 +143,13 @@ export default class RoapRequest extends StatelessWebexPlugin {
         };
       })
       .catch((err) => {
-        Metrics.postEvent({
-          event: eventType.MEDIA_RESPONSE,
-          meetingId,
-          data: {error: Metrics.parseLocusError(err, true)},
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.media.response',
+          options: {
+            meetingId,
+            rawError: err,
+          },
         });
         LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`);
         LoggerProxy.logger.error(

package/src/roap/turnDiscovery.ts

@@ -176,15 +176,14 @@ export default class TurnDiscovery {
     return this.roapRequest
       .sendRoap({
         roapMessage,
-        correlationId: meeting.correlationId,
         // @ts-ignore - Fix missing type
         locusSelfUrl: meeting.selfUrl,
         // @ts-ignore - Fix missing type
         mediaId: isReconnecting ? '' : meeting.mediaId,
-        audioMuted: meeting.audio?.isLocallyMuted(),
-        videoMuted: meeting.video?.isLocallyMuted(),
         meetingId: meeting.id,
-        preferTranscoding: !meeting.isMultistream,
+        locusMediaRequest: meeting.locusMediaRequest,
+        // @ts-ignore - because of meeting.webex
+        ipVersion: meeting.webex.meetings.reachability.getIpVersion(),
       })
       .then(({mediaConnections}) => {
         if (mediaConnections) {
@@ -213,14 +212,55 @@ export default class TurnDiscovery {
       locusSelfUrl: meeting.selfUrl,
       // @ts-ignore - fix type
       mediaId: meeting.mediaId,
-      correlationId: meeting.correlationId,
-      audioMuted: meeting.audio?.isLocallyMuted(),
-      videoMuted: meeting.video?.isLocallyMuted(),
       meetingId: meeting.id,
-      preferTranscoding: !meeting.isMultistream,
+      locusMediaRequest: meeting.locusMediaRequest,
+      // @ts-ignore - because of meeting.webex
+      ipVersion: meeting.webex.meetings.reachability.getIpVersion(),
     });
   }
 
+  /**
+   * Gets the reason why reachability is skipped.
+   *
+   * @param {Meeting} meeting
+   * @returns {Promise<string>} Promise with empty string if reachability is not skipped or a reason if it is skipped
+   */
+  private async getSkipReason(meeting: Meeting): Promise<string> {
+    // @ts-ignore - fix type
+    const isAnyClusterReachable = await meeting.webex.meetings.reachability.isAnyClusterReachable();
+
+    if (isAnyClusterReachable) {
+      LoggerProxy.logger.info(
+        'Roap:turnDiscovery#getSkipReason --> reachability has not failed, skipping TURN discovery'
+      );
+
+      return 'reachability';
+    }
+
+    // @ts-ignore - fix type
+    if (!meeting.config.experimental.enableTurnDiscovery) {
+      LoggerProxy.logger.info(
+        'Roap:turnDiscovery#getSkipReason --> TURN discovery disabled in config, skipping it'
+      );
+
+      return 'config';
+    }
+
+    return '';
+  }
+
+  /**
+   * Checks if TURN discovery is skipped.
+   *
+   * @param {Meeting} meeting
+   * @returns {Boolean} true if TURN discovery is being skipped, false if it is being done
+   */
+  async isSkipped(meeting) {
+    const skipReason = await this.getSkipReason(meeting);
+
+    return !!skipReason;
+  }
+
   /**
    * Retrieves TURN server information from the backend by doing
    * a roap message exchange:
@@ -239,29 +279,15 @@ export default class TurnDiscovery {
    * @returns {Promise}
    */
   async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean) {
-    // @ts-ignore - fix type
-    const isAnyClusterReachable = await meeting.webex.meetings.reachability.isAnyClusterReachable();
-
-    if (isAnyClusterReachable) {
-      LoggerProxy.logger.info(
-        'Roap:turnDiscovery#doTurnDiscovery --> reachability has not failed, skipping TURN discovery'
-      );
+    const turnDiscoverySkippedReason = await this.getSkipReason(meeting);
 
+    if (turnDiscoverySkippedReason) {
       return {
         turnServerInfo: undefined,
-        turnDiscoverySkippedReason: 'reachability',
+        turnDiscoverySkippedReason,
       };
     }
 
-    // @ts-ignore - fix type
-    if (!meeting.config.experimental.enableTurnDiscovery) {
-      LoggerProxy.logger.info(
-        'Roap:turnDiscovery#doTurnDiscovery --> TURN discovery disabled in config, skipping it'
-      );
-
-      return {turnServerInfo: undefined, turnDiscoverySkippedReason: 'config'};
-    }
-
     return this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting)
       .then(() => this.waitForTurnDiscoveryResponse())
       .then(() => this.sendRoapOK(meeting))

package/src/rtcMetrics/constants.ts

@@ -0,0 +1,3 @@
+const RTC_METRICS = {APP_ID: 'FFB51ED5-4319-4C55-8303-B1F2FCCDE231'};
+
+export {RTC_METRICS as default};

package/src/rtcMetrics/index.ts

@@ -0,0 +1,100 @@
+import RTC_METRICS from './constants';
+
+/**
+ * Rtc Metrics
+ */
+export default class RtcMetrics {
+  /**
+   * Array of MetricData items to be sent to the metrics service.
+   */
+  metricsQueue = [];
+
+  intervalId: number;
+
+  webex: any;
+
+  meetingId: string;
+
+  correlationId: string;
+
+  /**
+   * Initialize the interval.
+   *
+   * @param {object} webex - The main `webex` object.
+   * @param {string} meetingId - The meeting id.
+   * @param {string} correlationId - The correlation id.
+   */
+  constructor(webex, meetingId, correlationId) {
+    // `window` is used to prevent typescript from returning a NodeJS.Timer.
+    this.intervalId = window.setInterval(this.checkMetrics.bind(this), 30 * 1000);
+    this.meetingId = meetingId;
+    this.webex = webex;
+    this.correlationId = correlationId;
+    // Send the first set of metrics at 5 seconds in the case of a user leaving the call shortly after joining.
+    setTimeout(this.checkMetrics.bind(this), 5 * 1000);
+  }
+
+  /**
+   * Check to see if the metrics queue has any items.
+   *
+   * @returns {void}
+   */
+  private checkMetrics() {
+    if (this.metricsQueue.length) {
+      this.sendMetrics();
+      this.metricsQueue = [];
+    }
+  }
+
+  /**
+   * Add metrics items to the metrics queue.
+   *
+   * @param {object} data - An object with a payload array of metrics items.
+   *
+   * @returns {void}
+   */
+  addMetrics(data) {
+    if (data.payload.length) {
+      this.metricsQueue.push(data);
+    }
+  }
+
+  /**
+   * Clear the metrics interval.
+   *
+   * @returns {void}
+   */
+  closeMetrics() {
+    this.checkMetrics();
+    clearInterval(this.intervalId);
+  }
+
+  /**
+   * Send metrics to the metrics service.
+   *
+   * @returns {void}
+   */
+  private sendMetrics() {
+    this.webex.request({
+      method: 'POST',
+      service: 'unifiedTelemetry',
+      resource: 'metric/v2',
+      headers: {
+        type: 'webrtcMedia',
+        appId: RTC_METRICS.APP_ID,
+      },
+      body: {
+        metrics: [
+          {
+            type: 'webrtc',
+            version: '1.0.1',
+            userId: this.webex.internal.device.userId,
+            meetingId: this.meetingId,
+            correlationId: this.correlationId,
+            data: this.metricsQueue,
+          },
+        ],
+      },
+    });
+  }
+}

package/src/statsAnalyzer/index.ts

@@ -300,7 +300,6 @@ export class StatsAnalyzer extends EventsScope {
         this.mediaConnection = null;
       });
     }
-    this.mediaConnection = null;
 
     return Promise.resolve();
   }

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 {createCameraTrack, createMicrophoneTrack} 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 createMicrophoneTrack();
+        localTracks.alice.camera = await createCameraTrack();
+
+        localTracks.bob.microphone = await createMicrophoneTrack();
+        localTracks.bob.camera = await createCameraTrack();
+
+        localTracks.chris.microphone = await createMicrophoneTrack();
+        localTracks.chris.camera = await createCameraTrack();
+      });
+
       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, {multistream: true});
-        const addMediaBob = testUtils.addMedia(bob, {multistream: true});
-        const addMediaChris = testUtils.addMedia(chris, {multistream: true});
+        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;
+        }
+      });
     });
   }
 });