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

package/src/meetings/meetings.types.ts

@@ -0,0 +1,12 @@
+import type {
+  NoiseReductionEffectOptions,
+  VirtualBackgroundEffectOptions,
+} from '@webex/media-helpers';
+
+type INoiseReductionEffect = Omit<
+  NoiseReductionEffectOptions,
+  'authToken' | 'workletProcessorUrl' | 'legacyProcessorUrl'
+>;
+type IVirtualBackgroundEffect = Omit<VirtualBackgroundEffectOptions, 'authToken'>;
+
+export type {INoiseReductionEffect, IVirtualBackgroundEffect};

package/src/meetings/{request.js → request.ts}

@@ -1,11 +1,8 @@
+// @ts-ignore
 import {StatelessWebexPlugin} from '@webex/webex-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
-import {
-  HTTP_VERBS,
-  API,
-  RESOURCE
-} from '../constants';
+import {HTTP_VERBS, API, RESOURCE} from '../constants';
 
 /**
  * @class MeetingRequest
@@ -14,15 +11,19 @@ export default class MeetingRequest extends StatelessWebexPlugin {
   /**
    *  get all the active meetings for the user
    * @returns {Array} return locus array
-  */
+   */
   getActiveMeetings() {
+    // @ts-ignore
     return this.request({
       api: API.LOCUS,
-      resource: RESOURCE.LOCI
+      resource: RESOURCE.LOCI,
     })
       .then((res) => this.determineRedirections(res.body))
       .catch((error) => {
-        LoggerProxy.logger.error(`Meetings:request#getActiveMeetings --> failed to get locus details, ${error}`);
+        LoggerProxy.logger.error(
+          `Meetings:request#getActiveMeetings --> failed to get locus details, ${error}`
+        );
+        throw new Error(error);
       });
   }
 
@@ -31,18 +32,19 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @returns {Promise<object>} geoHintInfo
    */
   fetchGeoHint() {
+    // @ts-ignore
     return this.webex.internal.services.fetchClientRegionInfo();
   }
 
   /**
    * get user meeting preference information
    * @returns {Promise<object>} getMeetingPreferences
-  */
+   */
   getMeetingPreferences() {
+    // @ts-ignore
     return this.webex.internal.services.getMeetingPreferences();
   }
 
-
   // locus federation, determines and populate locus if the responseBody has remote URLs to fetch locus details
 
   /**
@@ -50,23 +52,30 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @param {object} responseBody determine the locus and fetch them if a remoteUrl is given
    * @returns {Promise}  returns locusObject array
    */
-  determineRedirections(responseBody) {
+  determineRedirections(responseBody: any) {
     if (responseBody.remoteLocusClusterUrls && responseBody.remoteLocusClusterUrls.length) {
-      return Promise.all(responseBody.remoteLocusClusterUrls.map((url) => this.request({
-        method: HTTP_VERBS.GET,
-        url,
-        runWhitelistedDomains: true // allows auth token for whitelisted domain
-      })
-        .then((res) => {
-          responseBody.loci = responseBody.loci.concat(res.body.loci);
-          responseBody.locusUrls = responseBody.locusUrls.concat(res.body.locusUrls);
+      return Promise.all(
+        responseBody.remoteLocusClusterUrls.map((url) =>
+          // @ts-ignore
+          this.request({
+            method: HTTP_VERBS.GET,
+            url,
+            runWhitelistedDomains: true, // allows auth token for whitelisted domain
+          })
+            .then((res) => {
+              responseBody.loci = responseBody.loci.concat(res.body.loci);
+              responseBody.locusUrls = responseBody.locusUrls.concat(res.body.locusUrls);
 
-          return Promise.resolve(responseBody);
-        })
-        .catch((error) => {
-          LoggerProxy.logger.error(`Meetings:request#determineRedirections --> failed to get locus details from url: ${url}, reason: ${error}`);
-        })))
-        .then(() => Promise.resolve(responseBody));
+              return Promise.resolve(responseBody);
+            })
+            .catch((error) => {
+              LoggerProxy.logger.error(
+                `Meetings:request#determineRedirections --> failed to get locus details from url: ${url}, reason: ${error}`
+              );
+              throw new Error(error);
+            })
+        )
+      ).then(() => Promise.resolve(responseBody));
     }
 
     return Promise.resolve(responseBody);

package/src/meetings/{util.js → util.ts}

@@ -1,36 +1,43 @@
 /* globals window */
 
 import {
-  _LOCUS_ID_,
-  _INCOMING_,
   _CREATED_,
-  LOCUSEVENT,
+  _INCOMING_,
+  _JOINED_,
+  _LEFT_,
+  _LOCUS_ID_,
+  _MOVED_,
+  BREAKOUTS,
   CORRELATION_ID,
   EVENT_TRIGGERS,
-  ROAP
+  LOCUS,
+  LOCUSEVENT,
+  ROAP,
 } from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 import Trigger from '../common/events/trigger-proxy';
+import BEHAVIORAL_METRICS from '../metrics/constants';
+import Metrics from '../metrics';
 
 /**
-  * Meetings Media Codec Missing Event
-  * Emitted when H.264 codec is not
-  * found in the browser.
-  * @event media:codec:missing
-  * @instance
-  * @memberof MeetingsUtil
-  */
+ * Meetings Media Codec Missing Event
+ * Emitted when H.264 codec is not
+ * found in the browser.
+ * @event media:codec:missing
+ * @instance
+ * @memberof MeetingsUtil
+ */
 
 /**
-  * Meetings Media Codec Loaded Event
-  * Emitted when H.264 codec has been
-  * loaded in the browser.
-  * @event media:codec:loaded
-  * @instance
-  * @memberof MeetingsUtil
-  */
+ * Meetings Media Codec Loaded Event
+ * Emitted when H.264 codec has been
+ * loaded in the browser.
+ * @event media:codec:loaded
+ * @instance
+ * @memberof MeetingsUtil
+ */
 
-const MeetingsUtil = {};
+const MeetingsUtil: any = {};
 
 MeetingsUtil.getMeetingAddedType = (type) => (type === _LOCUS_ID_ ? _INCOMING_ : _CREATED_);
 
@@ -42,31 +49,60 @@ MeetingsUtil.handleRoapMercury = (envelope, meetingCollection) => {
     const meeting = meetingCollection.getByKey(CORRELATION_ID, data.correlationId);
 
     if (meeting) {
-      const {
-        seq, messageType, tieBreaker, errorType, errorCause
-      } = data.message;
+      const {seq, messageType, tieBreaker, errorType, errorCause} = data.message;
+
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_MERCURY_EVENT_RECEIVED, {
+        correlation_id: data.correlationId,
+        seq,
+        message_type: messageType,
+        error_type: errorType,
+        error_cause: errorCause,
+      });
 
       if (messageType === ROAP.ROAP_TYPES.TURN_DISCOVERY_RESPONSE) {
         // turn discovery is not part of normal roap protocol and so we are not handling it
         // through the usual roap state machine
         meeting.roap.turnDiscovery.handleTurnDiscoveryResponse(data.message);
-      }
-      else {
+      } else {
         const roapMessage = {
           seq,
           messageType,
           sdp: data.message.sdps?.length > 0 ? data.message.sdps[0] : undefined,
           tieBreaker,
           errorType,
-          errorCause
+          errorCause,
         };
 
+        const mediaServer = MeetingsUtil.getMediaServer(roapMessage.sdp);
+
         meeting.mediaProperties.webrtcMediaConnection.roapMessageReceived(roapMessage);
+
+        if (mediaServer) {
+          meeting.mediaProperties.webrtcMediaConnection.mediaServer = mediaServer;
+        }
       }
     }
   }
 };
 
+MeetingsUtil.getMediaServer = (sdp) => {
+  let mediaServer;
+
+  // Attempt to collect the media server from the roap message.
+  try {
+    mediaServer = sdp
+      .split('\r\n')
+      .find((line) => line.startsWith('o='))
+      .split(' ')
+      .shift()
+      .replace('o=', '');
+  } catch {
+    mediaServer = undefined;
+  }
+
+  return mediaServer;
+};
+
 MeetingsUtil.checkForCorrelationId = (deviceUrl, locus) => {
   let devices = [];
 
@@ -88,11 +124,13 @@ MeetingsUtil.checkForCorrelationId = (deviceUrl, locus) => {
 MeetingsUtil.parseDefaultSiteFromMeetingPreferences = (userPreferences) => {
   let result = '';
 
-  if (userPreferences && userPreferences.sites) {
+  if (userPreferences?.sites?.length) {
     const defaultSite = userPreferences.sites.find((site) => site.default);
 
     if (defaultSite) {
       result = defaultSite.siteUrl;
+    } else {
+      result = userPreferences.sites[0].siteUrl;
     }
   }
 
@@ -116,15 +154,15 @@ MeetingsUtil.hasH264Codec = async () => {
       hasCodec = true;
     }
     pc.close();
-  }
-  catch (error) {
-    LoggerProxy.logger.warn('Meetings:util#hasH264Codec --> Error creating peerConnection for H.264 test.');
+  } catch (error) {
+    LoggerProxy.logger.warn(
+      'Meetings:util#hasH264Codec --> Error creating peerConnection for H.264 test.'
+    );
   }
 
   return hasCodec;
 };
 
-
 /**
  * Notifies the user whether or not the H.264
  * codec is present. Will continuously check
@@ -136,13 +174,16 @@ MeetingsUtil.hasH264Codec = async () => {
  * @param {boolean} options.disableNotifications Default is false. Boolean to enable/disable notification and events
  * @returns {undefined}
  */
-MeetingsUtil.checkH264Support = async function checkH264Support(options) {
+MeetingsUtil.checkH264Support = async function checkH264Support(options: {
+  firstChecked: number;
+  disableNotifications: boolean;
+}) {
   const {hasH264Codec} = MeetingsUtil;
   const {firstChecked, disableNotifications} = options || {};
   const delay = 5e3; // ms
   const maxDuration = 3e5; // ms
-  const shouldTrigger = (firstChecked === undefined);
-  const shouldStopChecking = firstChecked && (Date.now() - firstChecked) >= maxDuration;
+  const shouldTrigger = firstChecked === undefined;
+  const shouldStopChecking = firstChecked && Date.now() - firstChecked >= maxDuration;
 
   // Disable notifications and start H.264 download only
   if (disableNotifications) {
@@ -157,7 +198,7 @@ MeetingsUtil.checkH264Support = async function checkH264Support(options) {
       this,
       {
         file: 'meetings/util',
-        function: 'checkH264Support'
+        function: 'checkH264Support',
       },
       EVENT_TRIGGERS.MEDIA_CODEC_LOADED
     );
@@ -168,7 +209,9 @@ MeetingsUtil.checkH264Support = async function checkH264Support(options) {
 
   // Stop checking if past the timelimit
   if (shouldStopChecking) {
-    LoggerProxy.logger.error('Meetings:util#checkH264Support --> Timed out waiting for H264 codec to load.');
+    LoggerProxy.logger.error(
+      'Meetings:util#checkH264Support --> Timed out waiting for H264 codec to load.'
+    );
 
     return;
   }
@@ -179,7 +222,7 @@ MeetingsUtil.checkH264Support = async function checkH264Support(options) {
       this,
       {
         file: 'meetings/util',
-        function: 'checkH264Support'
+        function: 'checkH264Support',
       },
       EVENT_TRIGGERS.MEDIA_CODEC_MISSING
     );
@@ -194,4 +237,62 @@ MeetingsUtil.checkH264Support = async function checkH264Support(options) {
   }, delay);
 };
 
+/**
+ * get device from locus data
+ * @param {Object} newLocus new locus data
+ * @param {String} deviceUrl current device url
+ * @returns {Object}
+ */
+MeetingsUtil.getThisDevice = (newLocus: any, deviceUrl: string) => {
+  if (newLocus?.self?.devices?.length > 0) {
+    return newLocus.self.devices.find((device) => device.url === deviceUrl);
+  }
+
+  return null;
+};
+
+/**
+ * get self device joined status from locus data
+ * @param {Object} meeting current meeting data
+ * @param {Object} newLocus new locus data
+ * @param {String} deviceUrl current device url
+ * @returns {Object}
+ */
+MeetingsUtil.joinedOnThisDevice = (meeting: any, newLocus: any, deviceUrl: string) => {
+  const thisDevice = MeetingsUtil.getThisDevice(newLocus, deviceUrl);
+  if (thisDevice) {
+    if (!thisDevice.correlationId || meeting?.correlationId === thisDevice.correlationId) {
+      return (
+        thisDevice.state === _JOINED_ ||
+        (thisDevice.state === _LEFT_ && thisDevice.reason === _MOVED_)
+      );
+    }
+  }
+
+  return false;
+};
+
+/**
+ * check the new locus is breakout session's one or not
+ * @param {Object} newLocus new locus data
+ * @returns {boolean}
+ * @private
+ */
+MeetingsUtil.isBreakoutLocusDTO = (newLocus: any) => {
+  return newLocus?.controls?.breakout?.sessionType === BREAKOUTS.SESSION_TYPES.BREAKOUT;
+};
+
+/**
+ * check the locus is valid breakout locus or not
+ * @param {Object} locus
+ * @returns {boolean}
+ * @private
+ */
+MeetingsUtil.isValidBreakoutLocus = (locus: any) => {
+  const inActiveStatus = locus?.fullState?.state === LOCUS.STATE.INACTIVE;
+  const isLocusAsBreakout = MeetingsUtil.isBreakoutLocusDTO(locus);
+  const selfJoined = locus.self?.state === _JOINED_;
+
+  return isLocusAsBreakout && !inActiveStatus && selfJoined;
+};
 export default MeetingsUtil;