@webex/plugin-meetings 3.0.0-beta.26 → 3.0.0-beta.261

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

@@ -23,6 +23,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         LoggerProxy.logger.error(
           `Meetings:request#getActiveMeetings --> failed to get locus details, ${error}`
         );
+        throw new Error(error);
       });
   }
 
@@ -71,6 +72,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
               LoggerProxy.logger.error(
                 `Meetings:request#determineRedirections --> failed to get locus details from url: ${url}, reason: ${error}`
               );
+              throw new Error(error);
             })
         )
       ).then(() => Promise.resolve(responseBody));

package/src/meetings/util.ts

@@ -1,16 +1,23 @@
 /* globals window */
 
 import {
-  _LOCUS_ID_,
-  _INCOMING_,
   _CREATED_,
-  LOCUSEVENT,
+  _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';
+import BEHAVIORAL_METRICS from '../metrics/constants';
+import Metrics from '../metrics';
 
 /**
  * Meetings Media Codec Missing Event
@@ -44,6 +51,14 @@ MeetingsUtil.handleRoapMercury = (envelope, meetingCollection) => {
     if (meeting) {
       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
@@ -58,12 +73,36 @@ MeetingsUtil.handleRoapMercury = (envelope, meetingCollection) => {
           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 = [];
 
@@ -85,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;
     }
   }
 
@@ -196,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;

package/src/member/index.ts

@@ -2,6 +2,7 @@
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
 import {MEETINGS, _IN_LOBBY_, _NOT_IN_MEETING_, _IN_MEETING_} from '../constants';
+import {IExternalRoles, IMediaStatus, ParticipantWithRoles} from './types';
 
 import MemberUtil from './util';
 
@@ -28,10 +29,14 @@ export default class Member {
   isSelf: any;
   isUser: any;
   isVideoMuted: any;
+  roles: IExternalRoles;
+  mediaStatus: IMediaStatus;
   name: any;
   participant: any;
   status: any;
   supportsBreakouts: boolean;
+  supportsInterpretation: boolean;
+  supportLiveAnnotation: boolean;
   type: any;
   namespace = MEETINGS;
 
@@ -108,6 +113,13 @@ export default class Member {
      * @memberof Member
      */
     this.supportsBreakouts = null;
+    /**
+     * @instance
+     * @type {Boolean}
+     * @public
+     * @memberof Member
+     */
+    this.supportLiveAnnotation = null;
     /**
      * @instance
      * @type {Boolean}
@@ -228,6 +240,27 @@ export default class Member {
      * @memberof Member
      */
     this.isModeratorAssignmentProhibited = null;
+
+    /**
+     * @instance
+     * @type {IExternalRoles}
+     * @public
+     * @memberof Member
+     */
+    this.roles = null;
+
+    /**
+     * @instance
+     * @type {IMediaStatus}
+     * @public
+     * @memberof Member
+     * @example {audio: MediaStatus.RECVONLY, video: MediaStatus.SENDRECV}
+     */
+    this.mediaStatus = {
+      audio: null,
+      video: null,
+    };
+
     // TODO: more participant types
     // such as native client, web client, is a device, what type of phone, etc
     this.processParticipant(participant);
@@ -251,6 +284,8 @@ export default class Member {
       this.isVideoMuted = MemberUtil.isVideoMuted(participant);
       this.isHandRaised = MemberUtil.isHandRaised(participant);
       this.supportsBreakouts = MemberUtil.isBreakoutsSupported(participant);
+      this.supportsInterpretation = MemberUtil.isInterpretationSupported(participant);
+      this.supportLiveAnnotation = MemberUtil.isLiveAnnotationSupported(participant);
       this.isGuest = MemberUtil.isGuest(participant);
       this.isUser = MemberUtil.isUser(participant);
       this.isDevice = MemberUtil.isDevice(participant);
@@ -258,6 +293,7 @@ export default class Member {
       this.isModeratorAssignmentProhibited =
         MemberUtil.isModeratorAssignmentProhibited(participant);
       this.processStatus(participant);
+      this.processRoles(participant as ParticipantWithRoles);
       // must be done last
       this.isNotAdmitted = MemberUtil.isNotAdmitted(participant, this.isGuest, this.status);
     }
@@ -303,6 +339,8 @@ export default class Member {
       this.isAudioMuted,
       this.type
     );
+
+    this.mediaStatus = MemberUtil.extractMediaStatus(this.participant);
   }
 
   /**
@@ -427,6 +465,17 @@ export default class Member {
     }
   }
 
+  /**
+   * process the roles that have been applied to this member
+   * @param {Object} participant
+   * @returns {undefined}
+   * @private
+   * @memberof Member
+   */
+  private processRoles(participant: ParticipantWithRoles) {
+    this.roles = MemberUtil.extractControlRoles(participant);
+  }
+
   /**
    * set the type for the member, could be MEETING or CALL
    * @param {String} type

package/src/member/types.ts

@@ -0,0 +1,38 @@
+export interface IExternalRoles {
+  cohost: boolean;
+  moderator: boolean;
+  presenter: boolean;
+}
+
+export enum ServerRoles {
+  Cohost = 'COHOST',
+  Moderator = 'MODERATOR',
+  Presenter = 'PRESENTER',
+}
+
+export type ServerRoleShape = {
+  type: ServerRoles;
+  hasRole: boolean;
+};
+
+export type ParticipantWithRoles = {
+  controls: {
+    role: {
+      roles: Array<ServerRoleShape>;
+    };
+  };
+};
+
+// values are inherited from locus so don't update these
+export enum MediaStatus {
+  RECVONLY = 'RECVONLY', // participant only receiving and not sending
+  SENDONLY = 'SENDONLY', // participant only sending and not receiving
+  SENDRECV = 'SENDRECV', // participant both sending and receiving
+  INACTIVE = 'INACTIVE', // participant is not connected to media source
+  UNKNOWN = 'UNKNOWN', // participant has not added media in the meeting
+}
+
+export interface IMediaStatus {
+  audio: MediaStatus;
+  video: MediaStatus;
+}

package/src/member/util.ts

@@ -1,3 +1,10 @@
+import {
+  IExternalRoles,
+  ParticipantWithRoles,
+  ServerRoles,
+  ServerRoleShape,
+  IMediaStatus,
+} from './types';
 import {
   _USER_,
   _RESOURCE_ROOM_,
@@ -14,11 +21,65 @@ import {
   _SEND_RECEIVE_,
   _RECEIVE_ONLY_,
   _CALL_,
+  VIDEO,
+  AUDIO,
 } from '../constants';
 import ParameterError from '../common/errors/parameter';
 
 const MemberUtil: any = {};
 
+/**
+ * @param {Object} participant the locus participant
+ * @returns {[ServerRoleShape]}
+ */
+MemberUtil.getControlsRoles = (participant: ParticipantWithRoles): Array<ServerRoleShape> =>
+  participant?.controls?.role?.roles;
+
+/**
+ * @param {Object} participant the locus participant
+ * @param {ServerRoles} controlRole the search role
+ * @returns {Boolean}
+ */
+MemberUtil.hasRole = (participant: any, controlRole: ServerRoles): boolean =>
+  MemberUtil.getControlsRoles(participant)?.some(
+    (role) => role.type === controlRole && role.hasRole
+  );
+
+/**
+ * @param {Object} participant the locus participant
+ * @returns {Boolean}
+ */
+MemberUtil.hasCohost = (participant: ParticipantWithRoles): boolean =>
+  MemberUtil.hasRole(participant, ServerRoles.Cohost) || false;
+
+/**
+ * @param {Object} participant the locus participant
+ * @returns {Boolean}
+ */
+MemberUtil.hasModerator = (participant: ParticipantWithRoles): boolean =>
+  MemberUtil.hasRole(participant, ServerRoles.Moderator) || false;
+
+/**
+ * @param {Object} participant the locus participant
+ * @returns {Boolean}
+ */
+MemberUtil.hasPresenter = (participant: ParticipantWithRoles): boolean =>
+  MemberUtil.hasRole(participant, ServerRoles.Presenter) || false;
+
+/**
+ * @param {Object} participant the locus participant
+ * @returns {IExternalRoles}
+ */
+MemberUtil.extractControlRoles = (participant: ParticipantWithRoles): IExternalRoles => {
+  const roles = {
+    cohost: MemberUtil.hasCohost(participant),
+    moderator: MemberUtil.hasModerator(participant),
+    presenter: MemberUtil.hasPresenter(participant),
+  };
+
+  return roles;
+};
+
 /**
  * @param {Object} participant the locus participant
  * @returns {Boolean}
@@ -93,30 +154,20 @@ MemberUtil.isAudioMuted = (participant: any) => {
   if (!participant) {
     throw new ParameterError('Audio could not be processed, participant is undefined.');
   }
-  const mutedStatus = MemberUtil.isMuted(participant.status, AUDIO_STATUS);
 
-  if (participant.controls && participant.controls.audio) {
-    if (participant.controls.audio.muted) {
-      return true;
-    }
-    if (mutedStatus) {
-      return true;
-    }
-  }
-
-  return false;
+  return MemberUtil.isMuted(participant, AUDIO_STATUS, AUDIO);
 };
 
 /**
  * @param {Object} participant the locus participant
  * @returns {Boolean}
  */
-MemberUtil.isVideoMuted = (participant: any) => {
+MemberUtil.isVideoMuted = (participant: any): boolean => {
   if (!participant) {
     throw new ParameterError('Video could not be processed, participant is undefined.');
   }
 
-  return MemberUtil.isMuted(participant.status, VIDEO_STATUS);
+  return MemberUtil.isMuted(participant, VIDEO_STATUS, VIDEO);
 };
 
 /**
@@ -144,22 +195,57 @@ MemberUtil.isBreakoutsSupported = (participant) => {
 };
 
 /**
- * utility method for audio/video muted status
- * @param {String} status
- * @param {String} accessor
+ * @param {Object} participant the locus participant
  * @returns {Boolean}
  */
-MemberUtil.isMuted = (status: string, accessor: string) => {
-  if (status) {
-    if (status[accessor] === _RECEIVE_ONLY_) {
-      return true;
-    }
-    if (status[accessor] === _SEND_RECEIVE_) {
-      return false;
-    }
+MemberUtil.isInterpretationSupported = (participant) => {
+  if (!participant) {
+    throw new ParameterError(
+      'Interpretation support could not be processed, participant is undefined.'
+    );
   }
 
-  return null;
+  return !participant.doesNotSupportSiInterpreter;
+};
+
+/**
+ * @param {Object} participant the locus participant
+ * @returns {Boolean}
+ */
+MemberUtil.isLiveAnnotationSupported = (participant) => {
+  if (!participant) {
+    throw new ParameterError(
+      'LiveAnnotation support could not be processed, participant is undefined.'
+    );
+  }
+
+  return !participant.annotatorAssignmentNotAllowed;
+};
+
+/**
+ * utility method for audio/video muted status
+ * @param {any} participant
+ * @param {String} statusAccessor
+ * @param {String} controlsAccessor
+ * @returns {Boolean | undefined}
+ */
+MemberUtil.isMuted = (participant: any, statusAccessor: string, controlsAccessor: string) => {
+  // check remote mute
+  const remoteMute = participant?.controls?.[controlsAccessor]?.muted;
+  if (remoteMute === true) {
+    return true;
+  }
+
+  // check local mute
+  const localStatus = participant?.status?.[statusAccessor];
+  if (localStatus === _RECEIVE_ONLY_) {
+    return true;
+  }
+  if (localStatus === _SEND_RECEIVE_) {
+    return false;
+  }
+
+  return remoteMute;
 };
 
 /**
@@ -266,6 +352,22 @@ MemberUtil.extractId = (participant: any) => {
   return null;
 };
 
+/**
+ * extracts the media status from nested participant object
+ * @param {Object} participant the locus participant
+ * @returns {Object}
+ */
+MemberUtil.extractMediaStatus = (participant: any): IMediaStatus => {
+  if (!participant) {
+    throw new ParameterError('Media status could not be extracted, participant is undefined.');
+  }
+
+  return {
+    audio: participant.status?.audioStatus,
+    video: participant.status?.videoStatus,
+  };
+};
+
 /**
  * @param {Object} participant the locus participant
  * @returns {String}

package/src/members/collection.ts

@@ -37,4 +37,12 @@ export default class MembersCollection {
   getAll() {
     return this.members;
   }
+
+  /**
+   * @returns {void}
+   * reset members
+   */
+  reset() {
+    this.members = {};
+  }
 }