@webex/plugin-meetings 3.0.0-beta.13 → 3.0.0-beta.130

package/src/meeting/util.ts

@@ -1,17 +1,19 @@
-import {isEmpty} from 'lodash';
+import {LocalCameraTrack, LocalMicrophoneTrack} from '@webex/media-helpers';
 
+import {cloneDeep} from 'lodash';
 import {MeetingNotActiveError, UserNotJoinedError} from '../common/errors/webex-errors';
 import Metrics from '../metrics';
 import {eventType, trigger} from '../metrics/config';
-import Media from '../media';
 import LoggerProxy from '../common/logs/logger-proxy';
-import {INTENT_TO_JOIN,
+import {
+  INTENT_TO_JOIN,
   _LEFT_,
   _IDLE_,
   _JOINED_,
   PASSWORD_STATUS,
   DISPLAY_HINTS,
-  FULL_STATE} from '../constants';
+  FULL_STATE,
+} from '../constants';
 import IntentToJoinError from '../common/errors/intent-to-join';
 import JoinMeetingError from '../common/errors/join-meeting';
 import ParameterError from '../common/errors/parameter';
@@ -19,489 +21,537 @@ import PermissionError from '../common/errors/permission';
 import PasswordError from '../common/errors/password-error';
 import CaptchaError from '../common/errors/captcha-error';
 
-const MeetingUtil: any = {};
+const MeetingUtil = {
+  parseLocusJoin: (response) => {
+    const parsed: any = {};
+
+    // First todo: add check for existance
+    parsed.locus = response.body.locus;
+    parsed.mediaConnections = response.body.mediaConnections;
+    parsed.locusUrl = parsed.locus.url;
+    parsed.locusId = parsed.locus.url.split('/').pop();
+    parsed.selfId = parsed.locus.self.id;
+
+    // we need mediaId before making roap calls
+    parsed.mediaConnections.forEach((mediaConnection) => {
+      if (mediaConnection.mediaId) {
+        parsed.mediaId = mediaConnection.mediaId;
+      }
+    });
 
-MeetingUtil.parseLocusJoin = (response) => {
-  const parsed: any = {};
+    return parsed;
+  },
 
-  // First todo: add check for existance
-  parsed.locus = response.body.locus;
-  parsed.mediaConnections = response.body.mediaConnections;
-  parsed.locusUrl = parsed.locus.url;
-  parsed.locusId = parsed.locus.url.split('/').pop();
-  parsed.selfId = parsed.locus.self.id;
+  remoteUpdateAudioVideo: (meeting, audioMuted?: boolean, videoMuted?: boolean) => {
+    if (!meeting) {
+      return Promise.reject(new ParameterError('You need a meeting object.'));
+    }
 
-  // we need mediaId before making roap calls
-  parsed.mediaConnections.forEach((mediaConnection) => {
-    if (mediaConnection.mediaId) {
-      parsed.mediaId = mediaConnection.mediaId;
+    if (!meeting.locusMediaRequest) {
+      return Promise.reject(
+        new ParameterError(
+          'You need a meeting with a media connection, call Meeting.addMedia() first.'
+        )
+      );
     }
-  });
 
-  return parsed;
-};
+    Metrics.postEvent({event: eventType.MEDIA_REQUEST, meeting});
+
+    return meeting.locusMediaRequest
+      .send({
+        type: 'LocalMute',
+        selfUrl: meeting.selfUrl,
+        mediaId: meeting.mediaId,
+        sequence: meeting.locusInfo.sequence,
+        muteOptions: {
+          audioMuted,
+          videoMuted,
+        },
+      })
+      .then((response) => {
+        Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meeting});
+
+        return response?.body?.locus;
+      });
+  },
 
-MeetingUtil.remoteUpdateAudioVideo = (audioMuted, videoMuted, meeting) => {
-  if (!meeting) {
-    return Promise.reject(new ParameterError('You need a meeting object.'));
-  }
-  const localMedias = Media.generateLocalMedias(meeting.mediaId, audioMuted, videoMuted);
-
-  if (isEmpty(localMedias)) {
-    return Promise.reject(new ParameterError('You need a media id on the meeting to change remote audio.'));
-  }
-
-  Metrics.postEvent({event: eventType.MEDIA_REQUEST, meeting});
-
-  return meeting.meetingRequest.remoteAudioVideoToggle({
-    locusUrl: meeting.locusUrl,
-    selfId: meeting.selfId,
-    localMedias,
-    deviceUrl: meeting.deviceUrl,
-    correlationId: meeting.correlationId,
-    preferTranscoding: !meeting.isMultistream,
-  }).then((response) => {
-    Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meeting});
-
-    return response.body.locus;
-  });
-};
+  hasOwner: (info) => info && info.owner,
 
-MeetingUtil.hasOwner = (info) => info && info.owner;
+  isOwnerSelf: (owner, selfId) => owner === selfId,
 
-MeetingUtil.isOwnerSelf = (owner, selfId) => owner === selfId;
+  isPinOrGuest: (err) => err?.body?.errorCode && INTENT_TO_JOIN.includes(err.body.errorCode),
 
-MeetingUtil.isPinOrGuest = (err) => err?.body?.errorCode && INTENT_TO_JOIN.includes(err.body.errorCode);
+  joinMeeting: (meeting, options) => {
+    if (!meeting) {
+      return Promise.reject(new ParameterError('You need a meeting object.'));
+    }
 
-MeetingUtil.joinMeeting = (meeting, options) => {
-  if (!meeting) {
-    return Promise.reject(new ParameterError('You need a meeting object.'));
-  }
+    Metrics.postEvent({event: eventType.LOCUS_JOIN_REQUEST, meeting});
+
+    // eslint-disable-next-line no-warning-comments
+    // TODO: check if the meeting is in JOINING state
+    // if Joining state termintate the request as user might click multiple times
+    return meeting.meetingRequest
+      .joinMeeting({
+        inviteeAddress: meeting.meetingJoinUrl || meeting.sipUri,
+        meetingNumber: meeting.meetingNumber,
+        deviceUrl: meeting.deviceUrl,
+        locusUrl: meeting.locusUrl,
+        correlationId: meeting.correlationId,
+        roapMessage: options.roapMessage,
+        permissionToken: meeting.permissionToken,
+        resourceId: options.resourceId || null,
+        moderator: options.moderator,
+        pin: options.pin,
+        moveToResource: options.moveToResource,
+        preferTranscoding: !meeting.isMultistream,
+        asResourceOccupant: options.asResourceOccupant,
+        breakoutsSupported: options.breakoutsSupported,
+        locale: options.locale,
+        deviceCapabilities: options.deviceCapabilities,
+        liveAnnotationSupported: options.liveAnnotationSupported,
+      })
+      .then((res) => {
+        Metrics.postEvent({
+          event: eventType.LOCUS_JOIN_RESPONSE,
+          meeting,
+          data: {
+            trigger: trigger.LOCI_UPDATE,
+            locus: res.body.locus,
+            mediaConnections: res.body.mediaConnections,
+            trackingId: res.headers.trackingid,
+          },
+        });
 
-  Metrics.postEvent({event: eventType.LOCUS_JOIN_REQUEST, meeting});
+        return MeetingUtil.parseLocusJoin(res);
+      });
+  },
+
+  cleanUp: (meeting) => {
+    meeting.breakouts.cleanUp();
+
+    // make sure we send last metrics before we close the peerconnection
+    const stopStatsAnalyzer = meeting.statsAnalyzer
+      ? meeting.statsAnalyzer.stopAnalyzer()
+      : Promise.resolve();
+
+    return stopStatsAnalyzer
+      .then(() => meeting.closeLocalStream())
+      .then(() => meeting.closeLocalShare())
+      .then(() => meeting.closeRemoteTracks())
+      .then(() => meeting.closePeerConnections())
+      .then(() => {
+        meeting.unsetLocalVideoTrack();
+        meeting.unsetLocalShareTrack();
+        meeting.unsetRemoteTracks();
+        meeting.unsetPeerConnections();
+        meeting.reconnectionManager.cleanUp();
+      })
+      .then(() => meeting.stopKeepAlive())
+      .then(() => meeting.updateLLMConnection());
+  },
+
+  disconnectPhoneAudio: (meeting, phoneUrl) => {
+    if (meeting.meetingState === FULL_STATE.INACTIVE) {
+      return Promise.reject(new MeetingNotActiveError());
+    }
 
-  // eslint-disable-next-line no-warning-comments
-  // TODO: check if the meeting is in JOINING state
-  // if Joining state termintate the request as user might click multiple times
-  return meeting.meetingRequest
-    .joinMeeting({
-      inviteeAddress: meeting.meetingJoinUrl || meeting.sipUri,
-      meetingNumber: meeting.meetingNumber,
-      deviceUrl: meeting.deviceUrl,
+    const options = {
       locusUrl: meeting.locusUrl,
+      selfId: meeting.selfId,
       correlationId: meeting.correlationId,
-      roapMessage: options.roapMessage,
-      permissionToken: meeting.permissionToken,
-      resourceId: options.resourceId || null,
-      moderator: options.moderator,
-      pin: options.pin,
-      moveToResource: options.moveToResource,
-      preferTranscoding: !meeting.isMultistream,
-      asResourceOccupant: options.asResourceOccupant
-    })
-    .then((res) => {
-      Metrics.postEvent({
-        event: eventType.LOCUS_JOIN_RESPONSE,
-        meeting,
-        data: {
-          trigger: trigger.LOCI_UPDATE,
-          locus: res.body.locus,
-          mediaConnections: res.body.mediaConnections,
-          trackingId: res.headers.trackingid
-        }
-      });
+      phoneUrl,
+    };
 
-      return MeetingUtil.parseLocusJoin(res);
-    });
-};
-
-MeetingUtil.cleanUp = (meeting) => {
-  // make sure we send last metrics before we close the peerconnection
-  const stopStatsAnalyzer = (meeting.statsAnalyzer) ? meeting.statsAnalyzer.stopAnalyzer() : Promise.resolve();
-
-  return stopStatsAnalyzer
-    .then(() => meeting.closeLocalStream())
-    .then(() => meeting.closeLocalShare())
-    .then(() => meeting.closeRemoteTracks())
-    .then(() => meeting.closePeerConnections())
-    .then(() => {
-      meeting.unsetLocalVideoTrack();
-      meeting.unsetLocalShareTrack();
-      meeting.unsetRemoteTracks();
-      meeting.unsetPeerConnections();
-      meeting.reconnectionManager.cleanUp();
-    })
-    .then(() => meeting.stopKeepAlive())
-    .then(() => meeting.updateLLMConnection());
-};
-
-MeetingUtil.disconnectPhoneAudio = (meeting, phoneUrl) => {
-  if (meeting.meetingState === FULL_STATE.INACTIVE) {
-    return Promise.reject(new MeetingNotActiveError());
-  }
-
-  const options = {
-    locusUrl: meeting.locusUrl,
-    selfId: meeting.selfId,
-    correlationId: meeting.correlationId,
-    phoneUrl
-  };
-
-  return meeting.meetingRequest
-    .disconnectPhoneAudio(options)
-    .then((response) => {
-      if (response?.body?.locus) {
-        meeting.locusInfo.onFullLocus(response.body.locus);
-      }
-    })
-    .catch((err) => {
+    return meeting.meetingRequest.disconnectPhoneAudio(options).catch((err) => {
       LoggerProxy.logger.error(
-        `Meeting:util#disconnectPhoneAudio --> An error occured while disconnecting phone audio in meeting ${
-          meeting.id
-        }, error: ${err}`
+        `Meeting:util#disconnectPhoneAudio --> An error occured while disconnecting phone audio in meeting ${meeting.id}, error: ${err}`
       );
 
       return Promise.reject(err);
     });
-};
+  },
+
+  // by default will leave on meeting's resourceId
+  // if you explicity want it not to leave on resource id, pass
+  // {resourceId: null}
+  // TODO: chris, you can modify this however you want
+  leaveMeeting: (meeting, options: any = {}) => {
+    if (meeting.meetingState === FULL_STATE.INACTIVE) {
+      // TODO: clean up if the meeting is already inactive
+      return Promise.reject(new MeetingNotActiveError());
+    }
 
-// by default will leave on meeting's resourceId
-// if you explicity want it not to leave on resource id, pass
-// {resourceId: null}
-// TODO: chris, you can modify this however you want
-MeetingUtil.leaveMeeting = (meeting, options: any = {}) => {
-  if (meeting.meetingState === FULL_STATE.INACTIVE) {
-    // TODO: clean up if the meeting is already inactive
-    return Promise.reject(new MeetingNotActiveError());
-  }
-
-  if (MeetingUtil.isUserInLeftState(meeting.locusInfo)) {
-    return Promise.reject(new UserNotJoinedError());
-  }
-
-  const defaultOptions = {
-    locusUrl: meeting.locusUrl,
-    selfId: meeting.selfId,
-    correlationId: meeting.correlationId,
-    resourceId: meeting.resourceId,
-    deviceUrl: meeting.deviceUrl
-  };
-
-  const leaveOptions = {...defaultOptions, ...options};
-
-  return meeting.meetingRequest
-    .leaveMeeting(leaveOptions)
-    .then((response) => {
-      if (response && response.body && response.body.locus) { // && !options.moveMeeting) {
-        meeting.locusInfo.onFullLocus(response.body.locus);
-      }
+    if (MeetingUtil.isUserInLeftState(meeting.locusInfo)) {
+      return Promise.reject(new UserNotJoinedError());
+    }
 
-      return Promise.resolve();
-    })
-    .then(() => {
-      if (options.moveMeeting) {
-        return Promise.resolve();
-      }
+    const defaultOptions = {
+      locusUrl: meeting.locusUrl,
+      selfId: meeting.selfId,
+      correlationId: meeting.correlationId,
+      resourceId: meeting.resourceId,
+      deviceUrl: meeting.deviceUrl,
+    };
 
-      return MeetingUtil.cleanUp(meeting);
-    })
-    .catch((err) => {
-      // TODO: If the meeting state comes as LEFT or INACTIVE as response then
-      // 1)  on leave clean up the meeting or simply do a sync on the meeting
-      // 2) If the error says meeting is inactive then destroy the meeting object
-      LoggerProxy.logger.error(
-        `Meeting:util#leaveMeeting --> An error occured while trying to leave meeting with an id of ${
-          meeting.id
-        }, error: ${err}`
-      );
+    const leaveOptions = {...defaultOptions, ...options};
 
-      return Promise.reject(err);
-    });
-};
-MeetingUtil.declineMeeting = (meeting, reason) =>
-  meeting.meetingRequest.declineMeeting({
-    locusUrl: meeting.locusUrl,
-    deviceUrl: meeting.deviceUrl,
-    reason
-  });
+    return meeting.meetingRequest
+      .leaveMeeting(leaveOptions)
+      .then(() => {
+        if (options.moveMeeting) {
+          return Promise.resolve();
+        }
 
-MeetingUtil.isUserInLeftState = (locusInfo) =>
-  locusInfo.parsedLocus?.self?.state === _LEFT_;
+        return MeetingUtil.cleanUp(meeting);
+      })
+      .catch((err) => {
+        // TODO: If the meeting state comes as LEFT or INACTIVE as response then
+        // 1)  on leave clean up the meeting or simply do a sync on the meeting
+        // 2) If the error says meeting is inactive then destroy the meeting object
+        LoggerProxy.logger.error(
+          `Meeting:util#leaveMeeting --> An error occured while trying to leave meeting with an id of ${meeting.id}, error: ${err}`
+        );
+
+        return Promise.reject(err);
+      });
+  },
+  declineMeeting: (meeting, reason) =>
+    meeting.meetingRequest.declineMeeting({
+      locusUrl: meeting.locusUrl,
+      deviceUrl: meeting.deviceUrl,
+      reason,
+    }),
 
-MeetingUtil.isUserInIdleState = (locusInfo) =>
-  locusInfo.parsedLocus?.self?.state === _IDLE_;
+  isUserInLeftState: (locusInfo) => locusInfo.parsedLocus?.self?.state === _LEFT_,
 
-MeetingUtil.isUserInJoinedState = (locusInfo) =>
-  locusInfo.parsedLocus?.self?.state === _JOINED_;
+  isUserInIdleState: (locusInfo) => locusInfo.parsedLocus?.self?.state === _IDLE_,
 
-MeetingUtil.isMediaEstablished = (currentMediaStatus) =>
-  currentMediaStatus && (currentMediaStatus.audio || currentMediaStatus.video || currentMediaStatus.share);
+  isUserInJoinedState: (locusInfo) => locusInfo.parsedLocus?.self?.state === _JOINED_,
 
+  isMediaEstablished: (currentMediaStatus) =>
+    currentMediaStatus &&
+    (currentMediaStatus.audio || currentMediaStatus.video || currentMediaStatus.share),
 
-MeetingUtil.joinMeetingOptions = (meeting, options: any = {}) => {
-  meeting.resourceId = meeting.resourceId || options.resourceId;
+  joinMeetingOptions: (meeting, options: any = {}) => {
+    meeting.resourceId = meeting.resourceId || options.resourceId;
 
-  if (meeting.requiredCaptcha) {
-    return Promise.reject(new CaptchaError());
-  }
-  if (meeting.passwordStatus === PASSWORD_STATUS.REQUIRED) {
-    return Promise.reject(new PasswordError());
-  }
+    if (meeting.requiredCaptcha) {
+      return Promise.reject(new CaptchaError());
+    }
+    if (meeting.passwordStatus === PASSWORD_STATUS.REQUIRED) {
+      return Promise.reject(new PasswordError());
+    }
 
-  if (options.pin) {
-    Metrics.postEvent({
-      event: eventType.PIN_COLLECTED,
-      meeting
-    });
-  }
-
-  // normal join meeting, scenario A, D
-  return MeetingUtil.joinMeeting(meeting, options)
-    .then((response) => {
-      meeting.setLocus(response);
-
-      return Promise.resolve(response);
-    })
-    .catch((err) => {
-      // joining a claimed PMR that is not my own, scenario B
-      if (MeetingUtil.isPinOrGuest(err)) {
-        Metrics.postEvent({
-          event: eventType.PIN_PROMPT,
-          meeting
-        });
+    if (options.pin) {
+      Metrics.postEvent({
+        event: eventType.PIN_COLLECTED,
+        meeting,
+      });
+    }
 
-        // request host pin or non host for unclaimed PMR, start of Scenario C
-        // see https://sqbu-github.cisco.com/WebExSquared/locus/wiki/Locus-Lobby-and--IVR-Feature
-        return Promise.reject(new IntentToJoinError('Error Joining Meeting', err));
-      }
-      LoggerProxy.logger.error('Meeting:util#joinMeetingOptions --> Error joining the call, ', err);
+    // normal join meeting, scenario A, D
+    return MeetingUtil.joinMeeting(meeting, options)
+      .then((response) => {
+        meeting.setLocus(response);
+
+        return Promise.resolve(response);
+      })
+      .catch((err) => {
+        // joining a claimed PMR that is not my own, scenario B
+        if (MeetingUtil.isPinOrGuest(err)) {
+          Metrics.postEvent({
+            event: eventType.PIN_PROMPT,
+            meeting,
+          });
+
+          // request host pin or non host for unclaimed PMR, start of Scenario C
+          // see https://sqbu-github.cisco.com/WebExSquared/locus/wiki/Locus-Lobby-and--IVR-Feature
+          return Promise.reject(new IntentToJoinError('Error Joining Meeting', err));
+        }
+        LoggerProxy.logger.error(
+          'Meeting:util#joinMeetingOptions --> Error joining the call, ',
+          err
+        );
 
-      return Promise.reject(new JoinMeetingError(options, 'Error Joining Meeting', err));
-    });
-};
+        return Promise.reject(new JoinMeetingError(options, 'Error Joining Meeting', err));
+      });
+  },
 
-MeetingUtil.validateOptions = (options) => {
-  const {
-    sendVideo, sendAudio, sendShare, localStream, localShare
-  } = options;
+  validateOptions: (options) => {
+    const {sendVideo, sendAudio, sendShare, localStream, localShare} = options;
 
-  if (sendVideo && !MeetingUtil.getTrack(localStream).videoTrack) {
-    return Promise.reject(new ParameterError('please pass valid video streams'));
-  }
+    if (sendVideo && !MeetingUtil.getTrack(localStream).videoTrack) {
+      return Promise.reject(new ParameterError('please pass valid video streams'));
+    }
 
-  if (sendAudio && !MeetingUtil.getTrack(localStream).audioTrack) {
-    return Promise.reject(new ParameterError('please pass valid audio streams'));
-  }
+    if (sendAudio && !MeetingUtil.getTrack(localStream).audioTrack) {
+      return Promise.reject(new ParameterError('please pass valid audio streams'));
+    }
 
-  if (sendShare && !MeetingUtil.getTrack(localShare).videoTrack) {
-    return Promise.reject(new ParameterError('please pass valid share streams'));
-  }
+    if (sendShare && !MeetingUtil.getTrack(localShare).videoTrack) {
+      return Promise.reject(new ParameterError('please pass valid share streams'));
+    }
 
-  return Promise.resolve();
-};
+    return Promise.resolve();
+  },
 
-MeetingUtil.getTrack = (stream) => {
-  let audioTrack = null;
-  let videoTrack = null;
-  let audioTracks = null;
-  let videoTracks = null;
-
-  if (!stream) {
-    return {audioTrack: null, videoTrack: null};
-  }
-  if (stream.getAudioTracks) {
-    audioTracks = stream.getAudioTracks();
-  }
-  if (stream.getVideoTracks) {
-    videoTracks = stream.getVideoTracks();
-  }
-
-  if (audioTracks && audioTracks.length > 0) {
-    [audioTrack] = audioTracks;
-  }
-
-  if (videoTracks && videoTracks.length > 0) {
-    [videoTrack] = videoTracks;
-  }
-
-  return {audioTrack, videoTrack};
-};
+  getTrack: (stream) => {
+    let audioTrack = null;
+    let videoTrack = null;
+    let audioTracks = null;
+    let videoTracks = null;
 
-MeetingUtil.getModeratorFromLocusInfo = (locusInfo) =>
-  locusInfo &&
-  locusInfo.parsedLocus &&
-  locusInfo.parsedLocus.info &&
-  locusInfo.parsedLocus.info &&
-  locusInfo.parsedLocus.info.moderator;
+    if (!stream) {
+      return {audioTrack: null, videoTrack: null};
+    }
+    if (stream.getAudioTracks) {
+      audioTracks = stream.getAudioTracks();
+    }
+    if (stream.getVideoTracks) {
+      videoTracks = stream.getVideoTracks();
+    }
 
-MeetingUtil.getPolicyFromLocusInfo = (locusInfo) =>
-  locusInfo &&
-  locusInfo.parsedLocus &&
-  locusInfo.parsedLocus.info &&
-  locusInfo.parsedLocus.info &&
-  locusInfo.parsedLocus.info.policy;
+    if (audioTracks && audioTracks.length > 0) {
+      [audioTrack] = audioTracks;
+    }
 
-MeetingUtil.getUserDisplayHintsFromLocusInfo = (locusInfo) => locusInfo?.parsedLocus?.info?.userDisplayHints || [];
+    if (videoTracks && videoTracks.length > 0) {
+      [videoTrack] = videoTracks;
+    }
 
-MeetingUtil.canInviteNewParticipants = (displayHints) => displayHints.includes(DISPLAY_HINTS.ADD_GUEST);
+    return {audioTrack, videoTrack};
+  },
 
-MeetingUtil.canAdmitParticipant = (displayHints) => displayHints.includes(DISPLAY_HINTS.ROSTER_WAITING_TO_JOIN);
+  getModeratorFromLocusInfo: (locusInfo) =>
+    locusInfo &&
+    locusInfo.parsedLocus &&
+    locusInfo.parsedLocus.info &&
+    locusInfo.parsedLocus.info &&
+    locusInfo.parsedLocus.info.moderator,
 
-MeetingUtil.canUserLock = (displayHints) => displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_LOCK) && displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_UNLOCKED);
+  getPolicyFromLocusInfo: (locusInfo) =>
+    locusInfo &&
+    locusInfo.parsedLocus &&
+    locusInfo.parsedLocus.info &&
+    locusInfo.parsedLocus.info &&
+    locusInfo.parsedLocus.info.policy,
 
-MeetingUtil.canUserUnlock = (displayHints) => displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_UNLOCK) && displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_LOCKED);
+  getUserDisplayHintsFromLocusInfo: (locusInfo) =>
+    locusInfo?.parsedLocus?.info?.userDisplayHints || [],
 
-MeetingUtil.canUserRecord = (displayHints) => displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START);
+  canInviteNewParticipants: (displayHints) => displayHints.includes(DISPLAY_HINTS.ADD_GUEST),
 
-MeetingUtil.canUserPause = (displayHints) => displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE);
+  canAdmitParticipant: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.ROSTER_WAITING_TO_JOIN),
 
-MeetingUtil.canUserResume = (displayHints) => displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME);
+  canUserLock: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_LOCK) &&
+    displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_UNLOCKED),
 
-MeetingUtil.canUserStop = (displayHints) => displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP);
+  canUserUnlock: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_UNLOCK) &&
+    displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_LOCKED),
 
-MeetingUtil.startRecording = (request, locusUrl, locusInfo) => {
-  const displayHints = MeetingUtil.getUserDisplayHintsFromLocusInfo(locusInfo);
+  canUserRaiseHand: (displayHints) => displayHints.includes(DISPLAY_HINTS.RAISE_HAND),
 
-  if (MeetingUtil.canUserRecord(displayHints)) {
-    return request.recordMeeting({locusUrl, recording: true, paused: false});
-  }
+  canUserLowerAllHands: (displayHints) => displayHints.includes(DISPLAY_HINTS.LOWER_ALL_HANDS),
 
-  return Promise.reject(new PermissionError('Start recording not allowed, due to moderator property.'));
-};
+  canUserLowerSomeoneElsesHand: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LOWER_SOMEONE_ELSES_HAND),
 
-MeetingUtil.pauseRecording = (request, locusUrl, locusInfo) => {
-  const displayHints = MeetingUtil.getUserDisplayHintsFromLocusInfo(locusInfo);
+  bothLeaveAndEndMeetingAvailable: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LEAVE_TRANSFER_HOST_END_MEETING) ||
+    displayHints.includes(DISPLAY_HINTS.LEAVE_END_MEETING),
 
-  if (MeetingUtil.canUserPause(displayHints)) {
-    return request.recordMeeting({locusUrl, recording: true, paused: true});
-  }
+  canManageBreakout: (displayHints) => displayHints.includes(DISPLAY_HINTS.BREAKOUT_MANAGEMENT),
 
-  return Promise.reject(new PermissionError('Pause recording not allowed, due to moderator property.'));
-};
+  isSuppressBreakoutSupport: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.UCF_SUPPRESS_BREAKOUTS_SUPPORT),
 
-MeetingUtil.resumeRecording = (request, locusUrl, locusInfo) => {
-  const displayHints = MeetingUtil.getUserDisplayHintsFromLocusInfo(locusInfo);
+  canAdmitLobbyToBreakout: (displayHints) =>
+    !displayHints.includes(DISPLAY_HINTS.DISABLE_LOBBY_TO_BREAKOUT),
 
-  if (MeetingUtil.canUserResume(displayHints)) {
-    return request.recordMeeting({locusUrl, recording: true, paused: false});
-  }
+  isBreakoutPreassignmentsEnabled: (displayHints) =>
+    !displayHints.includes(DISPLAY_HINTS.DISABLE_BREAKOUT_PREASSIGNMENTS),
 
-  return Promise.reject(new PermissionError('Resume recording not allowed, due to moderator property.'));
-};
+  canUserAskForHelp: (displayHints) => !displayHints.includes(DISPLAY_HINTS.DISABLE_ASK_FOR_HELP),
 
-MeetingUtil.stopRecording = (request, locusUrl, locusInfo) => {
-  const displayHints = MeetingUtil.getUserDisplayHintsFromLocusInfo(locusInfo);
+  lockMeeting: (actions, request, locusUrl) => {
+    if (actions && actions.canLock) {
+      return request.lockMeeting({locusUrl, lock: true});
+    }
 
-  if (MeetingUtil.canUserStop(displayHints)) {
-    return request.recordMeeting({locusUrl, recording: false, paused: false});
-  }
+    return Promise.reject(new PermissionError('Lock not allowed, due to joined property.'));
+  },
 
-  return Promise.reject(new PermissionError('Stop recording not allowed, due to moderator property.'));
-};
+  unlockMeeting: (actions, request, locusUrl) => {
+    if (actions && actions.canUnlock) {
+      return request.lockMeeting({locusUrl, lock: false});
+    }
 
-MeetingUtil.canUserRaiseHand = (displayHints) => displayHints.includes(DISPLAY_HINTS.RAISE_HAND);
+    return Promise.reject(new PermissionError('Unlock not allowed, due to joined property.'));
+  },
 
-MeetingUtil.canUserLowerAllHands = (displayHints) => displayHints.includes(DISPLAY_HINTS.LOWER_ALL_HANDS);
+  handleAudioLogging: (audioTrack: LocalMicrophoneTrack | null) => {
+    const LOG_HEADER = 'MeetingUtil#handleAudioLogging -->';
 
-MeetingUtil.canUserLowerSomeoneElsesHand = (displayHints) => displayHints.includes(DISPLAY_HINTS.LOWER_SOMEONE_ELSES_HAND);
+    if (audioTrack) {
+      const settings = audioTrack.underlyingTrack.getSettings();
+      const {deviceId} = settings;
 
-MeetingUtil.bothLeaveAndEndMeetingAvailable = (displayHints) => displayHints.includes(DISPLAY_HINTS.LEAVE_TRANSFER_HOST_END_MEETING) || displayHints.includes(DISPLAY_HINTS.LEAVE_END_MEETING);
+      LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
+      LoggerProxy.logger.log(LOG_HEADER, 'settings =', JSON.stringify(settings));
+    }
+  },
 
-MeetingUtil.lockMeeting = (actions, request, locusUrl) => {
-  if (actions && actions.canLock) {
-    return request.lockMeeting({locusUrl, lock: true});
-  }
+  handleVideoLogging: (videoTrack: LocalCameraTrack | null) => {
+    const LOG_HEADER = 'MeetingUtil#handleVideoLogging -->';
 
-  return Promise.reject(new PermissionError('Lock not allowed, due to joined property.'));
-};
+    if (videoTrack) {
+      const settings = videoTrack.underlyingTrack.getSettings();
+      const {deviceId} = settings;
 
-MeetingUtil.unlockMeeting = (actions, request, locusUrl) => {
-  if (actions && actions.canUnlock) {
-    return request.lockMeeting({locusUrl, lock: false});
-  }
+      LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
+      LoggerProxy.logger.log(LOG_HEADER, 'settings =', JSON.stringify(settings));
+    }
+  },
 
-  return Promise.reject(new PermissionError('Unlock not allowed, due to joined property.'));
-};
+  handleDeviceLogging: (devices = []) => {
+    const LOG_HEADER = 'MeetingUtil#handleDeviceLogging -->';
 
-MeetingUtil.handleAudioLogging = (audioTrack) => {
-  const LOG_HEADER = 'MeetingUtil#handleAudioLogging -->';
+    devices.forEach((device) => {
+      LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${device.deviceId}`);
+      LoggerProxy.logger.log(LOG_HEADER, 'settings', JSON.stringify(device));
+    });
+  },
 
-  if (audioTrack) {
-    const settings = audioTrack.getSettings();
-    const {deviceId} = settings;
+  endMeetingForAll: (meeting) => {
+    if (meeting.meetingState === FULL_STATE.INACTIVE) {
+      return Promise.reject(new MeetingNotActiveError());
+    }
 
-    LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
-    LoggerProxy.logger.log(LOG_HEADER, 'settings =', JSON.stringify(settings));
-  }
-};
+    const endOptions = {
+      locusUrl: meeting.locusUrl,
+    };
 
-MeetingUtil.handleVideoLogging = (videoTrack) => {
-  const LOG_HEADER = 'MeetingUtil#handleVideoLogging -->';
+    return meeting.meetingRequest
+      .endMeetingForAll(endOptions)
+      .then(() => MeetingUtil.cleanUp(meeting))
+      .catch((err) => {
+        LoggerProxy.logger.error(
+          `Meeting:util#endMeetingForAll An error occured while trying to end meeting for all with an id of ${meeting.id}, error: ${err}`
+        );
 
-  if (videoTrack) {
-    const settings = videoTrack.getSettings();
-    const {deviceId} = settings;
+        return Promise.reject(err);
+      });
+  },
 
-    LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
-    LoggerProxy.logger.log(LOG_HEADER, 'settings =', JSON.stringify(settings));
-  }
-};
+  canEnableClosedCaption: (displayHints) => displayHints.includes(DISPLAY_HINTS.CAPTION_START),
 
-MeetingUtil.handleDeviceLogging = (devices = []) => {
-  const LOG_HEADER = 'MeetingUtil#handleDeviceLogging -->';
+  isSaveTranscriptsEnabled: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.SAVE_TRANSCRIPTS_ENABLED),
 
-  devices.forEach((device) => {
-    LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${device.deviceId}`);
-    LoggerProxy.logger.log(LOG_HEADER, 'settings', JSON.stringify(device));
-  });
-};
+  canStartTranscribing: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_START),
 
-MeetingUtil.endMeetingForAll = (meeting) => {
-  if (meeting.meetingState === FULL_STATE.INACTIVE) {
-    return Promise.reject(new MeetingNotActiveError());
-  }
+  canStopTranscribing: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_STOP),
 
-  const endOptions = {
-    locusUrl: meeting.locusUrl,
-  };
+  isClosedCaptionActive: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.CAPTION_STATUS_ACTIVE),
 
-  return meeting.meetingRequest
-    .endMeetingForAll(endOptions)
-    .then((response) => {
-      if (response && response.body && response.body.locus) {
-        meeting.locusInfo.onFullLocus(response.body.locus);
-      }
+  isWebexAssistantActive: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.WEBEX_ASSISTANT_STATUS_ACTIVE),
 
-      return Promise.resolve();
-    })
-    .then(() => MeetingUtil.cleanUp(meeting))
-    .catch((err) => {
-      LoggerProxy.logger.error(
-        `Meeting:util#endMeetingForAll An error occured while trying to end meeting for all with an id of ${
-          meeting.id
-        }, error: ${err}`
-      );
+  canViewCaptionPanel: (displayHints) => displayHints.includes(DISPLAY_HINTS.ENABLE_CAPTION_PANEL),
 
-      return Promise.reject(err);
-    });
-};
+  isRealTimeTranslationEnabled: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.DISPLAY_REAL_TIME_TRANSLATION),
+
+  canSelectSpokenLanguages: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.DISPLAY_NON_ENGLISH_ASR),
+
+  waitingForOthersToJoin: (displayHints) => displayHints.includes(DISPLAY_HINTS.WAITING_FOR_OTHERS),
+
+  canSendReactions: (originalValue, displayHints) => {
+    if (displayHints.includes(DISPLAY_HINTS.REACTIONS_ACTIVE)) {
+      return true;
+    }
+    if (displayHints.includes(DISPLAY_HINTS.REACTIONS_INACTIVE)) {
+      return false;
+    }
+
+    return originalValue;
+  },
+  canUserRenameSelfAndObserved: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.CAN_RENAME_SELF_AND_OBSERVED),
 
-MeetingUtil.canEnableClosedCaption = (displayHints) => displayHints.includes(DISPLAY_HINTS.CAPTION_START);
+  canUserRenameOthers: (displayHints) => displayHints.includes(DISPLAY_HINTS.CAN_RENAME_OTHERS),
 
-MeetingUtil.canStartTranscribing = (displayHints) => displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_START);
+  /**
+   * Adds the current locus sequence information to a request body
+   * @param {Object} meeting The meeting object
+   * @param {Object} requestBody The body of a request to locus
+   * @returns {void}
+   */
+  addSequence: (meeting, requestBody) => {
+    const sequence = meeting?.locusInfo?.sequence;
 
-MeetingUtil.canStopTranscribing = (displayHints) => displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_STOP);
+    if (!sequence) {
+      return;
+    }
+
+    requestBody.sequence = sequence;
+  },
+
+  /**
+   * Updates the locus info for the meeting with the delta locus
+   * returned from requests that include the sequence information
+   * Returns the original response object
+   * @param {Object} meeting The meeting object
+   * @param {Object} response The response of the http request
+   * @returns {Object}
+   */
+  updateLocusWithDelta: (meeting, response) => {
+    if (!meeting) {
+      return response;
+    }
 
-MeetingUtil.isClosedCaptionActive = (displayHints) => displayHints.includes(DISPLAY_HINTS.CAPTION_STATUS_ACTIVE);
+    const locus = response?.body?.locus;
 
-MeetingUtil.isWebexAssistantActive = (displayHints) => displayHints.includes(DISPLAY_HINTS.WEBEX_ASSISTANT_STATUS_ACTIVE);
+    if (locus) {
+      meeting.locusInfo.onDeltaLocus(locus);
+    }
 
-MeetingUtil.canViewCaptionPanel = (displayHints) => displayHints.includes(DISPLAY_HINTS.ENABLE_CAPTION_PANEL);
+    return response;
+  },
 
-MeetingUtil.isRealTimeTranslationEnabled = (displayHints) => displayHints.includes(DISPLAY_HINTS.DISPLAY_REAL_TIME_TRANSLATION);
+  generateLocusDeltaRequest: (originalMeeting) => {
+    const meetingRef = new WeakRef(originalMeeting);
 
-MeetingUtil.canSelectSpokenLanguages = (displayHints) => displayHints.includes(DISPLAY_HINTS.DISPLAY_NON_ENGLISH_ASR);
+    const locusDeltaRequest = (originalOptions) => {
+      const meeting = meetingRef.deref();
+
+      if (!meeting) {
+        return Promise.resolve();
+      }
 
-MeetingUtil.waitingForOthersToJoin = (displayHints) => displayHints.includes(DISPLAY_HINTS.WAITING_FOR_OTHERS);
+      const options = cloneDeep(originalOptions);
+
+      if (!options.body) {
+        options.body = {};
+      }
+
+      MeetingUtil.addSequence(meeting, options.body);
+
+      return meeting
+        .request(options)
+        .then((response) => MeetingUtil.updateLocusWithDelta(meeting, response));
+    };
+
+    return locusDeltaRequest;
+  },
+};
 
 export default MeetingUtil;