@webex/plugin-meetings 2.60.0 → 2.60.1-next.2

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,15 +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
@@ -41,11 +49,54 @@ MeetingsUtil.handleRoapMercury = (envelope, meetingCollection) => {
     const meeting = meetingCollection.getByKey(CORRELATION_ID, data.correlationId);
 
     if (meeting) {
-      meeting.roap.roapEvent(data);
+      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 {
+        const roapMessage = {
+          seq,
+          messageType,
+          sdp: data.message.sdps?.length > 0 ? data.message.sdps[0] : undefined,
+          tieBreaker,
+          errorType,
+          errorCause,
+        };
+
+        meeting.roapMessageReceived(roapMessage);
+      }
     }
   }
 };
 
+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 = [];
 
@@ -67,11 +118,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;
     }
   }
 
@@ -178,4 +231,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,7 +2,7 @@
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
 import {MEETINGS, _IN_LOBBY_, _NOT_IN_MEETING_, _IN_MEETING_} from '../constants';
-import {IMediaStatus} from './member.types';
+import {IExternalRoles, IMediaStatus, ParticipantWithRoles} from './types';
 
 import MemberUtil from './util';
 
@@ -30,10 +30,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;
 
@@ -110,6 +114,20 @@ export default class Member {
      * @memberof Member
      */
     this.isHandRaised = null;
+    /**
+     * @instance
+     * @type {Boolean}
+     * @public
+     * @memberof Member
+     */
+    this.supportsBreakouts = null;
+    /**
+     * @instance
+     * @type {Boolean}
+     * @public
+     * @memberof Member
+     */
+    this.supportLiveAnnotation = null;
     /**
      * @instance
      * @type {Boolean}
@@ -230,6 +248,15 @@ export default class Member {
      * @memberof Member
      */
     this.isModeratorAssignmentProhibited = null;
+
+    /**
+     * @instance
+     * @type {IExternalRoles}
+     * @public
+     * @memberof Member
+     */
+    this.roles = null;
+
     /**
      * @instance
      * @type {IMediaStatus}
@@ -264,6 +291,9 @@ export default class Member {
       this.isAudioMuted = MemberUtil.isAudioMuted(participant);
       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);
@@ -271,6 +301,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);
     }
@@ -442,6 +473,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,9 +21,10 @@ import {
   _SEND_RECEIVE_,
   _RECEIVE_ONLY_,
   _CALL_,
+  VIDEO,
+  AUDIO,
 } from '../constants';
 import ParameterError from '../common/errors/parameter';
-import {IMediaStatus} from './member.types';
 
 const MemberUtil: any = {};
 
@@ -34,6 +42,58 @@ MemberUtil.canReclaimHost = (participant) => {
   return participant.canReclaimHostRole || false;
 };
 
+/**
+ * @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}
@@ -108,30 +168,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);
 };
 
 /**
@@ -147,22 +197,69 @@ MemberUtil.isHandRaised = (participant: any) => {
 };
 
 /**
- * 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.isBreakoutsSupported = (participant) => {
+  if (!participant) {
+    throw new ParameterError('Breakout support could not be processed, participant is undefined.');
   }
 
-  return null;
+  return !participant.doesNotSupportBreakouts;
+};
+
+/**
+ * @param {Object} participant the locus participant
+ * @returns {Boolean}
+ */
+MemberUtil.isInterpretationSupported = (participant) => {
+  if (!participant) {
+    throw new ParameterError(
+      'Interpretation support could not be processed, participant is undefined.'
+    );
+  }
+
+  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;
 };
 
 /**
@@ -280,8 +377,8 @@ MemberUtil.extractMediaStatus = (participant: any): IMediaStatus => {
   }
 
   return {
-    audio: participant.status.audioStatus,
-    video: participant.status.videoStatus,
+    audio: participant.status?.audioStatus,
+    video: participant.status?.videoStatus,
   };
 };
 

package/src/members/collection.ts

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