@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.104

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.ts

@@ -0,0 +1,288 @@
+/* globals window */
+
+import {
+  _CREATED_,
+  _INCOMING_,
+  _JOINED_,
+  _LEFT_,
+  _LOCUS_ID_,
+  _MOVED_,
+  BREAKOUTS,
+  CORRELATION_ID,
+  EVENT_TRIGGERS,
+  LOCUS,
+  LOCUSEVENT,
+  ROAP,
+} from '../constants';
+import LoggerProxy from '../common/logs/logger-proxy';
+import Trigger from '../common/events/trigger-proxy';
+
+/**
+ * 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
+ */
+
+const MeetingsUtil: any = {};
+
+MeetingsUtil.getMeetingAddedType = (type) => (type === _LOCUS_ID_ ? _INCOMING_ : _CREATED_);
+
+MeetingsUtil.handleRoapMercury = (envelope, meetingCollection) => {
+  const {data} = envelope;
+  const {eventType} = data;
+
+  if (eventType === LOCUSEVENT.MESSAGE_ROAP) {
+    const meeting = meetingCollection.getByKey(CORRELATION_ID, data.correlationId);
+
+    if (meeting) {
+      const {seq, messageType, tieBreaker, errorType, errorCause} = data.message;
+
+      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 {
+        const roapMessage = {
+          seq,
+          messageType,
+          sdp: data.message.sdps?.length > 0 ? data.message.sdps[0] : undefined,
+          tieBreaker,
+          errorType,
+          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 = [];
+
+  if (locus) {
+    if (locus && locus.self && locus.self.devices) {
+      devices = locus.self.devices;
+    }
+
+    const foundDevice = devices.find((device) => device.url === deviceUrl);
+
+    if (foundDevice && foundDevice.correlationId) {
+      return foundDevice.correlationId;
+    }
+  }
+
+  return false;
+};
+
+MeetingsUtil.parseDefaultSiteFromMeetingPreferences = (userPreferences) => {
+  let result = '';
+
+  if (userPreferences?.sites?.length) {
+    const defaultSite = userPreferences.sites.find((site) => site.default);
+
+    if (defaultSite) {
+      result = defaultSite.siteUrl;
+    } else {
+      result = userPreferences.sites[0].siteUrl;
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Will check to see if the H.264 media codec is supported.
+ * @async
+ * @private
+ * @returns {Promise<boolean>}
+ */
+MeetingsUtil.hasH264Codec = async () => {
+  let hasCodec = false;
+
+  try {
+    const pc = new window.RTCPeerConnection();
+    const offer = await pc.createOffer({offerToReceiveVideo: true});
+
+    if (offer.sdp.match(/^a=rtpmap:\d+\s+H264\/\d+/m)) {
+      hasCodec = true;
+    }
+    pc.close();
+  } 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
+ * until max duration.
+ * @async
+ * @private
+ * @param {object} options
+ * @param {Number} options.firstChecked Timestamp in milliseconds
+ * @param {boolean} options.disableNotifications Default is false. Boolean to enable/disable notification and events
+ * @returns {undefined}
+ */
+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;
+
+  // Disable notifications and start H.264 download only
+  if (disableNotifications) {
+    hasH264Codec();
+
+    return;
+  }
+
+  // Codec loaded trigger event notification
+  if (await hasH264Codec()) {
+    Trigger.trigger(
+      this,
+      {
+        file: 'meetings/util',
+        function: 'checkH264Support',
+      },
+      EVENT_TRIGGERS.MEDIA_CODEC_LOADED
+    );
+    LoggerProxy.logger.log('Meetings:util#checkH264Support --> H264 codec loaded successfully.');
+
+    return;
+  }
+
+  // Stop checking if past the timelimit
+  if (shouldStopChecking) {
+    LoggerProxy.logger.error(
+      'Meetings:util#checkH264Support --> Timed out waiting for H264 codec to load.'
+    );
+
+    return;
+  }
+
+  // Trigger only once
+  if (shouldTrigger) {
+    Trigger.trigger(
+      this,
+      {
+        file: 'meetings/util',
+        function: 'checkH264Support',
+      },
+      EVENT_TRIGGERS.MEDIA_CODEC_MISSING
+    );
+    LoggerProxy.logger.log('Meetings:util#checkH264Support --> H264 codec is missing.');
+  }
+
+  // Keep checking in intervals to see if codec loaded
+  window.setTimeout(() => {
+    const timestamp = firstChecked || Date.now();
+
+    MeetingsUtil.checkH264Support.call(this, {firstChecked: timestamp});
+  }, 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;