@webex/plugin-meetings 3.0.0-beta.11 → 3.0.0-beta.111

package/src/controls-options-manager/types.ts

@@ -0,0 +1,59 @@
+import {Control} from './enums';
+
+export interface ControlProperties {
+  /**
+   * A list of additional properties that apply to various specific settings.
+   *
+   * @remarks
+   * The values stored here, per the service, are fully ambiguous, an can vary
+   * depending on which control scope is being configured.
+   */
+  [key: string]: boolean;
+}
+
+export interface AudioProperties {
+  muted?: boolean;
+  disallowUnmute?: boolean;
+  muteOnEntry?: boolean;
+}
+
+export interface RaiseHandProperties {
+  enabled?: boolean;
+}
+
+export interface ReactionsProperties {
+  enabled?: boolean;
+  showDisplayNameWithReactions?: boolean;
+}
+
+export interface ShareControlProperties {
+  control?: 'ANYONE' | 'MODERATOR_PRESENTER';
+}
+
+export interface VideoProperties {
+  enabled?: boolean;
+}
+
+export interface ViewTheParticipantListProperties {
+  enabled?: boolean;
+}
+
+export type Properties =
+  | AudioProperties
+  | RaiseHandProperties
+  | ReactionsProperties
+  | ShareControlProperties
+  | VideoProperties
+  | ViewTheParticipantListProperties;
+
+export interface ControlConfig<Props = Properties> {
+  /**
+   * The scope of the control within this object.
+   */
+  scope: Control;
+
+  /**
+   * The properties to assign to this control.
+   */
+  properties: Props;
+}

package/src/controls-options-manager/util.ts

@@ -0,0 +1,274 @@
+import {DISPLAY_HINTS} from '../constants';
+import {Control} from './enums';
+import {
+  ControlConfig,
+  AudioProperties,
+  RaiseHandProperties,
+  ReactionsProperties,
+  ViewTheParticipantListProperties,
+  VideoProperties,
+} from './types';
+
+/**
+ * The Controls Options Manager utilities
+ *
+ * @internal
+ */
+class Utils {
+  /**
+   * Validate if enabling mute on entry can be set.
+   *
+   * @param {Array<string>} displayHints - Display Hints to use when validating.
+   * @returns {boolean} - True if the action is allowed.
+   */
+  public static canSetMuteOnEntry(displayHints: Array<string>): boolean {
+    return displayHints.includes(DISPLAY_HINTS.ENABLE_MUTE_ON_ENTRY);
+  }
+
+  /**
+   * Validate if allowing unmuting can be set.
+   *
+   * @param {Array<string>} displayHints - Display Hints to use when validating.
+   * @returns {boolean} - True if the action is allowed.
+   */
+  public static canSetDisallowUnmute(displayHints: Array<string>): boolean {
+    return displayHints.includes(DISPLAY_HINTS.ENABLE_HARD_MUTE);
+  }
+
+  /**
+   * Validate if disabling mute on entry can be set.
+   *
+   * @param {Array<string>} displayHints - Display Hints to use when validating.
+   * @returns {boolean} - True if the action is allowed.
+   */
+  public static canUnsetMuteOnEntry(displayHints: Array<string>): boolean {
+    return displayHints.includes(DISPLAY_HINTS.DISABLE_MUTE_ON_ENTRY);
+  }
+
+  /**
+   * Validate if enabling muting can be set.
+   *
+   * @param {Array<string>} displayHints - Display Hints to use when validating.
+   * @returns {boolean} - True if the action is allowed.
+   */
+  public static canUnsetDisallowUnmute(displayHints: Array<string>): boolean {
+    return displayHints.includes(DISPLAY_HINTS.DISABLE_HARD_MUTE);
+  }
+
+  /**
+   * Validate if muting all can be set.
+   *
+   * @param {Array<string>} displayHints - Display Hints to use when validating.
+   * @returns {boolean} - True if the action is allowed.
+   */
+  public static canSetMuted(displayHints: Array<string>): boolean {
+    return displayHints.includes(DISPLAY_HINTS.MUTE_ALL);
+  }
+
+  /**
+   * Validate if unmuting all can be set.
+   *
+   * @param {Array<string>} displayHints - Display Hints to use when validating.
+   * @returns {boolean} - True if the action is allowed.
+   */
+  public static canUnsetMuted(displayHints: Array<string>): boolean {
+    return displayHints.includes(DISPLAY_HINTS.UNMUTE_ALL);
+  }
+
+  /**
+   * Validate an array of hints are allowed based on a full collection of hints.
+   *
+   * @param {Object} config - Configuration Object.
+   * @param {Array<string>} config.requiredHints - Hints required for validation.
+   * @param {Array<string>} config.displayHints - All available hints.
+   * @returns {boolean} - True if all of the actions are allowed.
+   */
+  public static hasHints(config: {requiredHints: Array<string>; displayHints: Array<string>}) {
+    const {requiredHints, displayHints} = config;
+
+    return requiredHints.every((hint) => displayHints.includes(hint));
+  }
+
+  /**
+   * Validate if an audio-scoped control is allowed to be sent to the service.
+   *
+   * @param {ControlConfig<AudioProperties>} control - Audio control config to validate.
+   * @param {Array<string>} displayHints - All available hints.
+   * @returns {boolean} - True if all of the actions are allowed.
+   */
+  public static canUpdateAudio(
+    control: ControlConfig<AudioProperties>,
+    displayHints: Array<string>
+  ) {
+    const requiredHints = [];
+
+    if (control.properties.muted === true) {
+      requiredHints.push(DISPLAY_HINTS.MUTE_ALL);
+    }
+    if (control.properties.muted === false) {
+      requiredHints.push(DISPLAY_HINTS.UNMUTE_ALL);
+    }
+    if (control.properties.disallowUnmute === true) {
+      requiredHints.push(DISPLAY_HINTS.ENABLE_HARD_MUTE);
+    }
+    if (control.properties.disallowUnmute === false) {
+      requiredHints.push(DISPLAY_HINTS.DISABLE_HARD_MUTE);
+    }
+    if (control.properties.muteOnEntry === true) {
+      requiredHints.push(DISPLAY_HINTS.ENABLE_MUTE_ON_ENTRY);
+    }
+    if (control.properties.muteOnEntry === false) {
+      requiredHints.push(DISPLAY_HINTS.DISABLE_MUTE_ON_ENTRY);
+    }
+
+    return Utils.hasHints({requiredHints, displayHints});
+  }
+
+  public static canUpdateRaiseHand(
+    control: ControlConfig<RaiseHandProperties>,
+    displayHints: Array<string>
+  ) {
+    const requiredHints = [];
+
+    if (control.properties.enabled === true) {
+      requiredHints.push(DISPLAY_HINTS.ENABLE_RAISE_HAND);
+    }
+    if (control.properties.enabled === false) {
+      requiredHints.push(DISPLAY_HINTS.DISABLE_RAISE_HAND);
+    }
+
+    return Utils.hasHints({requiredHints, displayHints});
+  }
+
+  /**
+   * Validate if an reactions-scoped control is allowed to be sent to the service.
+   *
+   * @param {ControlConfig<ReactionsProperties>} control - Reaction control config to validate.
+   * @param {Array<string>} displayHints - All available hints.
+   * @returns {boolean} - True if all of the actions are allowed.
+   */
+  public static canUpdateReactions(
+    control: ControlConfig<ReactionsProperties>,
+    displayHints: Array<string>
+  ) {
+    const requiredHints = [];
+
+    if (control.properties.enabled === true) {
+      requiredHints.push(DISPLAY_HINTS.ENABLE_REACTIONS);
+    }
+    if (control.properties.enabled === false) {
+      requiredHints.push(DISPLAY_HINTS.DISABLE_REACTIONS);
+    }
+    if (control.properties.showDisplayNameWithReactions === true) {
+      requiredHints.push(DISPLAY_HINTS.ENABLE_SHOW_DISPLAY_NAME);
+    }
+    if (control.properties.showDisplayNameWithReactions === false) {
+      requiredHints.push(DISPLAY_HINTS.DISABLE_SHOW_DISPLAY_NAME);
+    }
+
+    return Utils.hasHints({requiredHints, displayHints});
+  }
+
+  /**
+   * Validate if an share-control-scoped control is allowed to be sent to the service.
+   *
+   * @param {Array<string>} displayHints - All available hints.
+   * @returns {boolean} - True if all of the actions are allowed.
+   */
+  public static canUpdateShareControl(displayHints: Array<string>) {
+    return Utils.hasHints({requiredHints: [DISPLAY_HINTS.SHARE_CONTROL], displayHints});
+  }
+
+  /**
+   * Validate if an view-the-participants-list-scoped control is allowed to be sent to the service.
+   *
+   * @param {ControlConfig<ViewTheParticipantListProperties>} control - View Participants List control config to validate.
+   * @param {Array<string>} displayHints - All available hints.
+   * @returns {boolean} - True if all of the actions are allowed.
+   */
+  public static canUpdateViewTheParticipantsList(
+    control: ControlConfig<ViewTheParticipantListProperties>,
+    displayHints: Array<string>
+  ) {
+    const requiredHints = [];
+
+    if (control.properties.enabled === true) {
+      requiredHints.push(DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST);
+    }
+    if (control.properties.enabled === false) {
+      requiredHints.push(DISPLAY_HINTS.DISABLE_VIEW_THE_PARTICIPANT_LIST);
+    }
+
+    return Utils.hasHints({requiredHints, displayHints});
+  }
+
+  public static canUpdateVideo(
+    control: ControlConfig<VideoProperties>,
+    displayHints: Array<string>
+  ) {
+    const requiredHints = [];
+
+    if (control.properties.enabled === true) {
+      requiredHints.push(DISPLAY_HINTS.ENABLE_VIDEO);
+    }
+    if (control.properties.enabled === false) {
+      requiredHints.push(DISPLAY_HINTS.DISABLE_VIDEO);
+    }
+
+    return Utils.hasHints({requiredHints, displayHints});
+  }
+
+  /**
+   * Validate that a control can be sent to the service based on the provided
+   * display hints.
+   *
+   * @param {ControlConfig} control - Control to validate.
+   * @param {Array<string>} displayHints - All available hints.
+   * @returns {boolean} - True if all of the actions are allowed.
+   */
+  public static canUpdate(control: ControlConfig, displayHints: Array<string>) {
+    let determinant: boolean;
+
+    switch (control.scope) {
+      case Control.audio:
+        determinant = Utils.canUpdateAudio(control as ControlConfig<AudioProperties>, displayHints);
+        break;
+
+      case Control.raiseHand:
+        determinant = Utils.canUpdateRaiseHand(
+          control as ControlConfig<RaiseHandProperties>,
+          displayHints
+        );
+        break;
+
+      case Control.reactions:
+        determinant = Utils.canUpdateReactions(
+          control as ControlConfig<ReactionsProperties>,
+          displayHints
+        );
+        break;
+
+      case Control.shareControl:
+        determinant = Utils.canUpdateShareControl(displayHints);
+        break;
+
+      case Control.video:
+        determinant = Utils.canUpdateVideo(control as ControlConfig<VideoProperties>, displayHints);
+        break;
+
+      case Control.viewTheParticipantList:
+        determinant = Utils.canUpdateViewTheParticipantsList(
+          control as ControlConfig<ViewTheParticipantListProperties>,
+          displayHints
+        );
+        break;
+
+      default:
+        determinant = false;
+    }
+
+    return determinant;
+  }
+}
+
+export default Utils;

package/src/index.ts

@@ -0,0 +1,33 @@
+/* eslint-env browser */
+import {registerPlugin} from '@webex/webex-core';
+
+import Meetings from './meetings';
+import config from './config';
+
+registerPlugin('meetings', Meetings, {
+  config,
+});
+
+export {
+  LocalTrack,
+  LocalDisplayTrack,
+  LocalTrackEvents,
+  type TrackMuteEvent,
+  type ServerMuteReason,
+  LocalMicrophoneTrackEvents,
+  LocalCameraTrackEvents,
+  LocalMicrophoneTrack,
+  LocalCameraTrack,
+  createMicrophoneTrack,
+  createCameraTrack,
+  createDisplayTrack,
+} from '@webex/media-helpers';
+
+export default Meetings;
+
+export * as CONSTANTS from './constants';
+export * as REACTIONS from './reactions/reactions';
+
+export {RemoteMedia} from './multistream/remoteMedia';
+
+export {default as TriggerProxy} from './common/events/trigger-proxy';

package/src/locus-info/controlsUtils.ts

@@ -1,4 +1,5 @@
 import {isEqual} from 'lodash';
+import {BREAKOUTS} from '../constants';
 
 const ControlsUtils: any = {};
 
@@ -25,25 +26,58 @@ ControlsUtils.parse = (controls: any) => {
       modifiedBy: ControlsUtils.getId(controls),
       paused: controls.record.paused ? controls.record.paused : false,
       recording: controls.record.recording,
-      lastModified: controls.record.meta.lastModified
+      lastModified: controls.record.meta.lastModified,
     };
   }
 
   if (controls && controls.meetingContainer) {
     parsedControls.meetingContainer = {
-      meetingContainerUrl: controls.meetingContainer.meetingContainerUrl
+      meetingContainerUrl: controls.meetingContainer.meetingContainerUrl,
     };
   }
 
   if (controls && controls.transcribe) {
     parsedControls.transcribe = {
       transcribing: controls.transcribe.transcribing,
-      caption: controls.transcribe.caption
+      caption: controls.transcribe.caption,
     };
   }
 
   if (controls && controls.entryExitTone) {
-    parsedControls.entryExitTone = controls.entryExitTone.enabled ? controls.entryExitTone.mode : null;
+    parsedControls.entryExitTone = controls.entryExitTone.enabled
+      ? controls.entryExitTone.mode
+      : null;
+  }
+
+  if (controls && controls.video) {
+    parsedControls.videoEnabled = controls.video.enabled;
+  }
+
+  if (controls?.muteOnEntry) {
+    parsedControls.muteOnEntry = {enabled: controls.muteOnEntry.enabled};
+  }
+
+  if (controls?.shareControl) {
+    parsedControls.shareControl = {control: controls.shareControl.control};
+  }
+
+  if (controls?.disallowUnmute) {
+    parsedControls.disallowUnmute = {enabled: controls.disallowUnmute.enabled};
+  }
+
+  if (controls?.reactions) {
+    parsedControls.reactions = {
+      enabled: controls.reactions.enabled,
+      showDisplayNameWithReactions: controls.reactions.showDisplayNameWithReactions,
+    };
+  }
+
+  if (controls?.viewTheParticipantList) {
+    parsedControls.viewTheParticipantList = {enabled: controls.viewTheParticipantList.enabled};
+  }
+
+  if (controls?.raiseHand) {
+    parsedControls.raiseHand = {enabled: controls.raiseHand.enabled};
   }
 
   return parsedControls;
@@ -63,26 +97,67 @@ ControlsUtils.getControls = (oldControls: any, newControls: any) => {
     previous,
     current,
     updates: {
-      hasRecordingPausedChanged: current?.record &&
-      !isEqual(previous?.record?.paused, current.record.paused) &&
-      (previous?.record?.recording || current?.record?.recording), // see comments directly below
-
-      hasRecordingChanged: current?.record &&
-      !isEqual(previous?.record?.recording, current?.record?.recording) && // upon first join, previous?.record?.recording = undefined; thus, never going to be equal and will always return true
-      (previous?.record?.recording || current?.record?.recording), // therefore, condition added to prevent false firings of #meeting:recording:stopped upon first joining a meeting
-
-      hasMeetingContainerChanged: current?.meetingContainer &&
-        !isEqual(previous?.meetingContainer?.meetingContainerUrl,
-          current?.meetingContainer?.meetingContainerUrl),
-
-      hasTranscribeChanged: current?.transcribe &&
-          !isEqual(previous?.transcribe?.transcribing, current?.transcribe?.transcribing) && // upon first join, previous?.record?.recording = undefined; thus, never going to be equal and will always return true
-          (previous?.transcribe?.transcribing || current?.transcribe?.transcribing), // therefore, condition added to prevent false firings of #meeting:recording:stopped upon first joining a meeting
-
-      hasEntryExitToneChanged: !!(newControls.entryExitTone &&
-          !isEqual(previous?.entryExitTone, current?.entryExitTone) &&
-          (previous?.entryExitTone || current?.entryExitTone)),
-    }
+      hasMuteOnEntryChanged:
+        current?.muteOnEntry?.enabled &&
+        current?.muteOnEntry?.enabled !== previous?.muteOnEntry?.enabled,
+
+      hasShareControlChanged:
+        current?.shareControl?.control &&
+        current?.shareControl?.control !== previous?.shareControl?.control,
+
+      hasDisallowUnmuteChanged:
+        current?.disallowUnmute?.enabled &&
+        current?.disallowUnmute?.enabled !== previous?.disallowUnmute?.enabled,
+
+      hasReactionsChanged:
+        current?.reactions?.enabled && current?.reactions?.enabled !== previous?.reactions?.enabled,
+
+      hasReactionDisplayNamesChanged:
+        current?.reactions?.showDisplayNameWithReactions &&
+        current?.reactions?.showDisplayNameWithReactions !==
+          previous?.reactions?.showDisplayNameWithReactions,
+
+      hasViewTheParticipantListChanged:
+        current?.viewTheParticipantList?.enabled &&
+        current?.viewTheParticipantList?.enabled !== previous?.viewTheParticipantList?.enabled,
+
+      hasRaiseHandChanged:
+        current?.raiseHand?.enabled && current?.raiseHand?.enabled !== previous?.raiseHand?.enabled,
+
+      hasRecordingPausedChanged:
+        current?.record &&
+        !isEqual(previous?.record?.paused, current.record.paused) &&
+        (previous?.record?.recording || current?.record?.recording), // see comments directly below
+
+      hasRecordingChanged:
+        current?.record &&
+        !isEqual(previous?.record?.recording, current?.record?.recording) && // upon first join, previous?.record?.recording = undefined; thus, never going to be equal and will always return true
+        (previous?.record?.recording || current?.record?.recording), // therefore, condition added to prevent false firings of #meeting:recording:stopped upon first joining a meeting
+
+      hasMeetingContainerChanged:
+        current?.meetingContainer &&
+        !isEqual(
+          previous?.meetingContainer?.meetingContainerUrl,
+          current?.meetingContainer?.meetingContainerUrl
+        ),
+
+      hasTranscribeChanged:
+        current?.transcribe &&
+        !isEqual(previous?.transcribe?.transcribing, current?.transcribe?.transcribing) && // upon first join, previous?.record?.recording = undefined; thus, never going to be equal and will always return true
+        (previous?.transcribe?.transcribing || current?.transcribe?.transcribing), // therefore, condition added to prevent false firings of #meeting:recording:stopped upon first joining a meeting
+
+      hasEntryExitToneChanged: !!(
+        newControls.entryExitTone &&
+        !isEqual(previous?.entryExitTone, current?.entryExitTone) &&
+        (previous?.entryExitTone || current?.entryExitTone)
+      ),
+
+      hasBreakoutChanged: !isEqual(previous?.breakout, current?.breakout),
+
+      hasVideoEnabledChanged:
+        newControls.video?.enabled !== undefined &&
+        !isEqual(previous?.videoEnabled, current?.videoEnabled),
+    },
   };
 };
 
@@ -99,4 +174,50 @@ ControlsUtils.getId = (controls: any) => {
   return null;
 };
 
+/**
+ * check whether to replace the meeting's members or not.
+ * For case joined breakout session, need replace meeting's members
+ * @param {LocusControls} oldControls
+ * @param {LocusControls} controls
+ * @returns {Boolean}
+ */
+ControlsUtils.isNeedReplaceMembers = (oldControls: any, controls: any) => {
+  // no breakout case
+  if (!oldControls?.breakout || !controls?.breakout) {
+    return false;
+  }
+
+  return (
+    oldControls.breakout.groupId !== controls.breakout.groupId ||
+    oldControls.breakout.sessionId !== controls.breakout.sessionId
+  );
+};
+
+/**
+ * determine the switch status between breakout session and main session.
+ * @param {LocusControls} oldControls
+ * @param {LocusControls} controls
+ * @returns {Object}
+ */
+ControlsUtils.getSessionSwitchStatus = (oldControls: any, controls: any) => {
+  const status = {isReturnToMain: false, isJoinToBreakout: false};
+  // no breakout case
+  if (!oldControls?.breakout || !controls?.breakout) {
+    return status;
+  }
+
+  status.isReturnToMain =
+    oldControls.breakout.sessionType === BREAKOUTS.SESSION_TYPES.BREAKOUT &&
+    controls.breakout.sessionType === BREAKOUTS.SESSION_TYPES.MAIN;
+  status.isJoinToBreakout =
+    oldControls.breakout.sessionType === BREAKOUTS.SESSION_TYPES.MAIN &&
+    controls.breakout.sessionType === BREAKOUTS.SESSION_TYPES.BREAKOUT;
+
+  return status;
+};
+
+ControlsUtils.isMainSessionDTO = (locus: any) => {
+  return locus?.controls?.breakout?.sessionType !== BREAKOUTS.SESSION_TYPES.BREAKOUT;
+};
+
 export default ControlsUtils;

package/src/locus-info/fullState.ts

@@ -5,10 +5,9 @@ const FullState: any = {};
 FullState.parse = (fullState) => ({
   type: fullState.type || FULL_STATE.UNKNOWN,
   meetingState: fullState.state,
-  locked: fullState.locked
+  locked: fullState.locked,
 });
 
-
 FullState.getFullState = (oldFullState, newFullState) => {
   const previous = oldFullState && FullState.parse(oldFullState);
   const current = newFullState && FullState.parse(newFullState);
@@ -20,16 +19,19 @@ FullState.getFullState = (oldFullState, newFullState) => {
       isMeetingEnded: FullState.isMeetingEnded(previous, current),
       isMeetingTerminating: FullState.isMeetingTerminating(previous, current),
       meetingTypeChangedTo: FullState.isTypeChanged(previous, current),
-      meetingStateChangedTo: FullState.meetingStateChange(previous, current)
-    }
+      meetingStateChangedTo: FullState.meetingStateChange(previous, current),
+    },
   };
 };
 
 FullState.isMeetingEnded = (previous, current) => {
-  if (current.state === FULL_STATE.INACTIVE && previous &&
-   (previous.state === FULL_STATE.ACTIVE ||
-    previous.state === FULL_STATE.INITIALIZING ||
-    previous.state === FULL_STATE.TERMINATING)) {
+  if (
+    current.state === FULL_STATE.INACTIVE &&
+    previous &&
+    (previous.state === FULL_STATE.ACTIVE ||
+      previous.state === FULL_STATE.INITIALIZING ||
+      previous.state === FULL_STATE.TERMINATING)
+  ) {
     return true;
   }
 
@@ -37,9 +39,11 @@ FullState.isMeetingEnded = (previous, current) => {
 };
 
 FullState.isMeetingTerminating = (previous, current) => {
-  if (current.state === FULL_STATE.TERMINATING && previous &&
-  (previous.state === FULL_STATE.ACTIVE ||
-    previous.state === FULL_STATE.INITIALIZING)) {
+  if (
+    current.state === FULL_STATE.TERMINATING &&
+    previous &&
+    (previous.state === FULL_STATE.ACTIVE || previous.state === FULL_STATE.INITIALIZING)
+  ) {
     return true;
   }
 

package/src/locus-info/hostUtils.ts

@@ -8,7 +8,7 @@ const HostUtils: any = {};
 HostUtils.parse = (host: object) => {
   if (host) {
     return {
-      hostId: HostUtils.getId(host)
+      hostId: HostUtils.getId(host),
     };
   }
 
@@ -30,8 +30,9 @@ HostUtils.getHosts = (oldHost: object, newHost: object) => {
     previous,
     current,
     updates: {
-      isNewHost: previous && current ? HostUtils.isDifferentHosts(previous.hostId, current.hostId) : true
-    }
+      isNewHost:
+        previous && current ? HostUtils.isDifferentHosts(previous.hostId, current.hostId) : true,
+    },
   };
 };