@webex/plugin-meetings 3.0.0-beta.39 → 3.0.0-beta.391

package/src/meeting/util.ts

@@ -1,10 +1,7 @@
-import {isEmpty} from 'lodash';
-import {LocalCameraTrack, LocalMicrophoneTrack} from '@webex/internal-media-core';
+import {LocalCameraStream, LocalMicrophoneStream} 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,
@@ -14,491 +11,784 @@ import {
   PASSWORD_STATUS,
   DISPLAY_HINTS,
   FULL_STATE,
+  SELF_POLICY,
+  EVENT_TRIGGERS,
+  LOCAL_SHARE_ERRORS,
+  IP_VERSION,
 } from '../constants';
+import BrowserDetection from '../common/browser-detection';
 import IntentToJoinError from '../common/errors/intent-to-join';
 import JoinMeetingError from '../common/errors/join-meeting';
 import ParameterError from '../common/errors/parameter';
 import PermissionError from '../common/errors/permission';
 import PasswordError from '../common/errors/password-error';
 import CaptchaError from '../common/errors/captcha-error';
+import Trigger from '../common/events/trigger-proxy';
+
+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;
+      }
+    });
+
+    return parsed;
+  },
+
+  remoteUpdateAudioVideo: (meeting, audioMuted?: boolean, videoMuted?: boolean) => {
+    const webex = meeting.getWebexObject();
+    if (!meeting) {
+      return Promise.reject(new ParameterError('You need a meeting object.'));
+    }
 
-const MeetingUtil: any = {};
+    if (!meeting.locusMediaRequest) {
+      return Promise.reject(
+        new ParameterError(
+          'You need a meeting with a media connection, call Meeting.addMedia() first.'
+        )
+      );
+    }
 
-MeetingUtil.parseLocusJoin = (response) => {
-  const parsed: any = {};
+    // @ts-ignore
+    webex.internal.newMetrics.submitClientEvent({
+      name: 'client.locus.media.request',
+      options: {meetingId: meeting.id},
+    });
 
-  // 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;
+    return meeting.locusMediaRequest
+      .send({
+        type: 'LocalMute',
+        selfUrl: meeting.selfUrl,
+        mediaId: meeting.mediaId,
+        sequence: meeting.locusInfo.sequence,
+        muteOptions: {
+          audioMuted,
+          videoMuted,
+        },
+      })
+      .then((response) => {
+        // @ts-ignore
+        webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.media.response',
+          options: {meetingId: meeting.id},
+        });
 
-  // we need mediaId before making roap calls
-  parsed.mediaConnections.forEach((mediaConnection) => {
-    if (mediaConnection.mediaId) {
-      parsed.mediaId = mediaConnection.mediaId;
+        return response?.body?.locus;
+      });
+  },
+
+  hasOwner: (info) => info && info.owner,
+
+  isOwnerSelf: (owner, selfId) => owner === selfId,
+
+  isPinOrGuest: (err) => err?.body?.errorCode && INTENT_TO_JOIN.includes(err.body.errorCode),
+
+  /**
+   * Returns the current state of knowledge about whether we are on an ipv4-only or ipv6-only or mixed (ipv4 and ipv6) network.
+   * The return value matches the possible values of "ipver" parameter used by the backend APIs.
+   *
+   * @param {Object} webex webex instance
+   * @returns {IP_VERSION|undefined} ipver value to be passed to the backend APIs or undefined if we should not pass any value to the backend
+   */
+  getIpVersion(webex: any): IP_VERSION | undefined {
+    const {supportsIpV4, supportsIpV6} = webex.internal.device.ipNetworkDetector;
+
+    if (BrowserDetection().isBrowser('firefox')) {
+      // our ipv6 solution relies on FQDN ICE candidates, but Firefox doesn't support them,
+      // see https://bugzilla.mozilla.org/show_bug.cgi?id=1713128
+      // so for Firefox we don't want the backend to activate the "ipv6 feature"
+      return undefined;
     }
-  });
 
-  return parsed;
-};
+    if (supportsIpV4 && supportsIpV6) {
+      return IP_VERSION.ipv4_and_ipv6;
+    }
+
+    if (supportsIpV4) {
+      return IP_VERSION.only_ipv4;
+    }
 
-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 (supportsIpV6) {
+      return IP_VERSION.only_ipv6;
+    }
 
-  if (isEmpty(localMedias)) {
-    return Promise.reject(
-      new ParameterError('You need a media id on the meeting to change remote audio.')
-    );
-  }
+    return IP_VERSION.unknown;
+  },
+
+  joinMeeting: (meeting, options) => {
+    if (!meeting) {
+      return Promise.reject(new ParameterError('You need a meeting object.'));
+    }
+    const webex = meeting.getWebexObject();
 
-  Metrics.postEvent({event: eventType.MEDIA_REQUEST, meeting});
+    // @ts-ignore
+    webex.internal.newMetrics.submitClientEvent({
+      name: 'client.locus.join.request',
+      options: {meetingId: meeting.id},
+    });
+
+    // 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,
+        locusClusterUrl: meeting.meetingInfo?.locusClusterUrl,
+        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,
+        ipVersion: MeetingUtil.getIpVersion(meeting.getWebexObject()),
+      })
+      .then((res) => {
+        // @ts-ignore
+        webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.join.response',
+          payload: {
+            trigger: 'loci-update',
+            identifiers: {
+              trackingId: res.headers.trackingid,
+            },
+          },
+          options: {
+            meetingId: meeting.id,
+            mediaConnections: res.body.mediaConnections,
+          },
+        });
 
-  return meeting.meetingRequest
-    .remoteAudioVideoToggle({
+        return MeetingUtil.parseLocusJoin(res);
+      });
+  },
+
+  cleanUp: (meeting) => {
+    meeting.breakouts.cleanUp();
+    meeting.simultaneousInterpretation.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.closeRemoteStreams())
+      .then(() => meeting.closePeerConnections())
+      .then(() => {
+        meeting.cleanupLocalStreams();
+        meeting.unsetRemoteStreams();
+        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());
+    }
+
+    const options = {
       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});
+      phoneUrl,
+    };
 
-      return response.body.locus;
+    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}`
+      );
+
+      return Promise.reject(err);
     });
-};
+  },
+
+  /**
+   * Returns options for leaving a meeting.
+   * @param {any} meeting
+   * @param {any} options
+   * @returns {any} leave options
+   */
+  prepareLeaveMeetingOptions: (meeting, options: any = {}) => {
+    const defaultOptions = {
+      locusUrl: meeting.locusUrl,
+      selfId: meeting.selfId,
+      correlationId: meeting.correlationId,
+      resourceId: meeting.resourceId,
+      deviceUrl: meeting.deviceUrl,
+    };
+
+    return {...defaultOptions, ...options};
+  },
+
+  // 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());
+    }
 
-MeetingUtil.hasOwner = (info) => info && info.owner;
+    if (MeetingUtil.isUserInLeftState(meeting.locusInfo)) {
+      return Promise.reject(new UserNotJoinedError());
+    }
 
-MeetingUtil.isOwnerSelf = (owner, selfId) => owner === selfId;
+    const leaveOptions = MeetingUtil.prepareLeaveMeetingOptions(meeting, options);
+
+    return meeting.meetingRequest
+      .leaveMeeting(leaveOptions)
+      .then(() => {
+        if (options.moveMeeting) {
+          return Promise.resolve();
+        }
+
+        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.isPinOrGuest = (err) =>
-  err?.body?.errorCode && INTENT_TO_JOIN.includes(err.body.errorCode);
+  isUserInLeftState: (locusInfo) => locusInfo.parsedLocus?.self?.state === _LEFT_,
 
-MeetingUtil.joinMeeting = (meeting, options) => {
-  if (!meeting) {
-    return Promise.reject(new ParameterError('You need a meeting object.'));
-  }
+  isUserInIdleState: (locusInfo) => locusInfo.parsedLocus?.self?.state === _IDLE_,
 
-  Metrics.postEvent({event: eventType.LOCUS_JOIN_REQUEST, meeting});
+  isUserInJoinedState: (locusInfo) => locusInfo.parsedLocus?.self?.state === _JOINED_,
 
-  // 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,
-    })
-    .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,
+  isMediaEstablished: (currentMediaStatus) =>
+    currentMediaStatus &&
+    (currentMediaStatus.audio || currentMediaStatus.video || currentMediaStatus.share),
+
+  joinMeetingOptions: (meeting, options: any = {}) => {
+    const webex = meeting.getWebexObject();
+
+    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 (options.pin) {
+      // @ts-ignore
+      webex.internal.newMetrics.submitClientEvent({
+        name: 'client.pin.collected',
+        options: {
+          meetingId: meeting.id,
         },
       });
+    }
 
-      return MeetingUtil.parseLocusJoin(res);
-    });
-};
+    // 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)) {
+          // @ts-ignore
+          webex.internal.newMetrics.submitClientEvent({
+            name: 'client.pin.prompt',
+            options: {
+              meetingId: meeting.id,
+            },
+          });
+
+          // 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));
+      });
+  },
+
+  /**
+   * Returns request options for leaving a meeting.
+   * @param {any} meeting
+   * @param {any} options
+   * @returns {any} request options
+   */
+  buildLeaveFetchRequestOptions: (meeting, options: any = {}) => {
+    const leaveOptions = MeetingUtil.prepareLeaveMeetingOptions(meeting, options);
+
+    return meeting.meetingRequest.buildLeaveMeetingRequestOptions(leaveOptions);
+  },
+
+  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();
+    }
 
-MeetingUtil.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());
-};
+    if (audioTracks && audioTracks.length > 0) {
+      [audioTrack] = audioTracks;
+    }
 
-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) => {
-      LoggerProxy.logger.error(
-        `Meeting:util#disconnectPhoneAudio --> An error occured while disconnecting phone audio in meeting ${meeting.id}, error: ${err}`
-      );
+    if (videoTracks && videoTracks.length > 0) {
+      [videoTrack] = videoTracks;
+    }
 
-      return Promise.reject(err);
-    });
-};
+    return {audioTrack, videoTrack};
+  },
 
-// 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);
-      }
+  getModeratorFromLocusInfo: (locusInfo) =>
+    locusInfo &&
+    locusInfo.parsedLocus &&
+    locusInfo.parsedLocus.info &&
+    locusInfo.parsedLocus.info &&
+    locusInfo.parsedLocus.info.moderator,
 
-      return Promise.resolve();
-    })
-    .then(() => {
-      if (options.moveMeeting) {
-        return Promise.resolve();
-      }
+  getPolicyFromLocusInfo: (locusInfo) =>
+    locusInfo &&
+    locusInfo.parsedLocus &&
+    locusInfo.parsedLocus.info &&
+    locusInfo.parsedLocus.info &&
+    locusInfo.parsedLocus.info.policy,
 
-      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}`
-      );
+  getUserDisplayHintsFromLocusInfo: (locusInfo) =>
+    locusInfo?.parsedLocus?.info?.userDisplayHints || [],
 
-      return Promise.reject(err);
-    });
-};
-MeetingUtil.declineMeeting = (meeting, reason) =>
-  meeting.meetingRequest.declineMeeting({
-    locusUrl: meeting.locusUrl,
-    deviceUrl: meeting.deviceUrl,
-    reason,
-  });
+  canInviteNewParticipants: (displayHints) => displayHints.includes(DISPLAY_HINTS.ADD_GUEST),
 
-MeetingUtil.isUserInLeftState = (locusInfo) => locusInfo.parsedLocus?.self?.state === _LEFT_;
+  canAdmitParticipant: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.ROSTER_WAITING_TO_JOIN),
 
-MeetingUtil.isUserInIdleState = (locusInfo) => locusInfo.parsedLocus?.self?.state === _IDLE_;
+  canUserLock: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_LOCK) &&
+    displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_UNLOCKED),
 
-MeetingUtil.isUserInJoinedState = (locusInfo) => locusInfo.parsedLocus?.self?.state === _JOINED_;
+  canUserUnlock: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_UNLOCK) &&
+    displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_LOCKED),
 
-MeetingUtil.isMediaEstablished = (currentMediaStatus) =>
-  currentMediaStatus &&
-  (currentMediaStatus.audio || currentMediaStatus.video || currentMediaStatus.share);
+  canUserRaiseHand: (displayHints) => displayHints.includes(DISPLAY_HINTS.RAISE_HAND),
 
-MeetingUtil.joinMeetingOptions = (meeting, options: any = {}) => {
-  meeting.resourceId = meeting.resourceId || options.resourceId;
+  canUserLowerAllHands: (displayHints) => displayHints.includes(DISPLAY_HINTS.LOWER_ALL_HANDS),
 
-  if (meeting.requiredCaptcha) {
-    return Promise.reject(new CaptchaError());
-  }
-  if (meeting.passwordStatus === PASSWORD_STATUS.REQUIRED) {
-    return Promise.reject(new PasswordError());
-  }
+  canUserLowerSomeoneElsesHand: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LOWER_SOMEONE_ELSES_HAND),
 
-  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,
-        });
+  bothLeaveAndEndMeetingAvailable: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LEAVE_TRANSFER_HOST_END_MEETING) ||
+    displayHints.includes(DISPLAY_HINTS.LEAVE_END_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);
+  canManageBreakout: (displayHints) => displayHints.includes(DISPLAY_HINTS.BREAKOUT_MANAGEMENT),
+  canBroadcastMessageToBreakout: (displayHints, policies = {}) =>
+    displayHints.includes(DISPLAY_HINTS.BROADCAST_MESSAGE_TO_BREAKOUT) &&
+    !!policies[SELF_POLICY.SUPPORT_BROADCAST_MESSAGE],
 
-      return Promise.reject(new JoinMeetingError(options, 'Error Joining Meeting', err));
-    });
-};
+  isSuppressBreakoutSupport: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.UCF_SUPPRESS_BREAKOUTS_SUPPORT),
 
-MeetingUtil.validateOptions = (options) => {
-  const {sendVideo, sendAudio, sendShare, localStream, localShare} = options;
+  canAdmitLobbyToBreakout: (displayHints) =>
+    !displayHints.includes(DISPLAY_HINTS.DISABLE_LOBBY_TO_BREAKOUT),
 
-  if (sendVideo && !MeetingUtil.getTrack(localStream).videoTrack) {
-    return Promise.reject(new ParameterError('please pass valid video streams'));
-  }
+  isBreakoutPreassignmentsEnabled: (displayHints) =>
+    !displayHints.includes(DISPLAY_HINTS.DISABLE_BREAKOUT_PREASSIGNMENTS),
 
-  if (sendAudio && !MeetingUtil.getTrack(localStream).audioTrack) {
-    return Promise.reject(new ParameterError('please pass valid audio streams'));
-  }
+  canUserAskForHelp: (displayHints) => !displayHints.includes(DISPLAY_HINTS.DISABLE_ASK_FOR_HELP),
 
-  if (sendShare && !MeetingUtil.getTrack(localShare).videoTrack) {
-    return Promise.reject(new ParameterError('please pass valid share streams'));
-  }
+  lockMeeting: (actions, request, locusUrl) => {
+    if (actions && actions.canLock) {
+      return request.lockMeeting({locusUrl, lock: true});
+    }
 
-  return Promise.resolve();
-};
+    return Promise.reject(new PermissionError('Lock not allowed, due to joined property.'));
+  },
 
-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};
-};
+  unlockMeeting: (actions, request, locusUrl) => {
+    if (actions && actions.canUnlock) {
+      return request.lockMeeting({locusUrl, lock: false});
+    }
+
+    return Promise.reject(new PermissionError('Unlock not allowed, due to joined property.'));
+  },
+
+  handleAudioLogging: (audioStream?: LocalMicrophoneStream) => {
+    const LOG_HEADER = 'MeetingUtil#handleAudioLogging -->';
+
+    if (audioStream) {
+      const settings = audioStream.getSettings();
+      const {deviceId} = settings;
+
+      LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
+      LoggerProxy.logger.log(LOG_HEADER, 'settings =', JSON.stringify(settings));
+    }
+  },
 
-MeetingUtil.getModeratorFromLocusInfo = (locusInfo) =>
-  locusInfo &&
-  locusInfo.parsedLocus &&
-  locusInfo.parsedLocus.info &&
-  locusInfo.parsedLocus.info &&
-  locusInfo.parsedLocus.info.moderator;
+  handleVideoLogging: (videoStream?: LocalCameraStream) => {
+    const LOG_HEADER = 'MeetingUtil#handleVideoLogging -->';
 
-MeetingUtil.getPolicyFromLocusInfo = (locusInfo) =>
-  locusInfo &&
-  locusInfo.parsedLocus &&
-  locusInfo.parsedLocus.info &&
-  locusInfo.parsedLocus.info &&
-  locusInfo.parsedLocus.info.policy;
+    if (videoStream) {
+      const settings = videoStream.getSettings();
+      const {deviceId} = settings;
 
-MeetingUtil.getUserDisplayHintsFromLocusInfo = (locusInfo) =>
-  locusInfo?.parsedLocus?.info?.userDisplayHints || [];
+      LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
+      LoggerProxy.logger.log(LOG_HEADER, 'settings =', JSON.stringify(settings));
+    }
+  },
 
-MeetingUtil.canInviteNewParticipants = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.ADD_GUEST);
+  handleDeviceLogging: (devices = []) => {
+    const LOG_HEADER = 'MeetingUtil#handleDeviceLogging -->';
 
-MeetingUtil.canAdmitParticipant = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.ROSTER_WAITING_TO_JOIN);
+    devices.forEach((device) => {
+      LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${device.deviceId}`);
+      LoggerProxy.logger.log(LOG_HEADER, 'settings', JSON.stringify(device));
+    });
+  },
 
-MeetingUtil.canUserLock = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_LOCK) &&
-  displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_UNLOCKED);
+  endMeetingForAll: (meeting) => {
+    if (meeting.meetingState === FULL_STATE.INACTIVE) {
+      return Promise.reject(new MeetingNotActiveError());
+    }
 
-MeetingUtil.canUserUnlock = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_UNLOCK) &&
-  displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_LOCKED);
+    const endOptions = {
+      locusUrl: meeting.locusUrl,
+    };
 
-MeetingUtil.canUserRaiseHand = (displayHints) => displayHints.includes(DISPLAY_HINTS.RAISE_HAND);
+    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}`
+        );
 
-MeetingUtil.canUserLowerAllHands = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.LOWER_ALL_HANDS);
+        return Promise.reject(err);
+      });
+  },
 
-MeetingUtil.canUserLowerSomeoneElsesHand = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.LOWER_SOMEONE_ELSES_HAND);
+  canEnableClosedCaption: (displayHints) => displayHints.includes(DISPLAY_HINTS.CAPTION_START),
 
-MeetingUtil.bothLeaveAndEndMeetingAvailable = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.LEAVE_TRANSFER_HOST_END_MEETING) ||
-  displayHints.includes(DISPLAY_HINTS.LEAVE_END_MEETING);
+  isSaveTranscriptsEnabled: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.SAVE_TRANSCRIPTS_ENABLED),
 
-MeetingUtil.lockMeeting = (actions, request, locusUrl) => {
-  if (actions && actions.canLock) {
-    return request.lockMeeting({locusUrl, lock: true});
-  }
+  canStartTranscribing: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_START),
 
-  return Promise.reject(new PermissionError('Lock not allowed, due to joined property.'));
-};
+  canStopTranscribing: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_STOP),
 
-MeetingUtil.unlockMeeting = (actions, request, locusUrl) => {
-  if (actions && actions.canUnlock) {
-    return request.lockMeeting({locusUrl, lock: false});
-  }
+  isClosedCaptionActive: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.CAPTION_STATUS_ACTIVE),
 
-  return Promise.reject(new PermissionError('Unlock not allowed, due to joined property.'));
-};
+  isWebexAssistantActive: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.WEBEX_ASSISTANT_STATUS_ACTIVE),
 
-MeetingUtil.handleAudioLogging = (audioTrack: LocalMicrophoneTrack | null) => {
-  const LOG_HEADER = 'MeetingUtil#handleAudioLogging -->';
+  canViewCaptionPanel: (displayHints) => displayHints.includes(DISPLAY_HINTS.ENABLE_CAPTION_PANEL),
 
-  if (audioTrack) {
-    const settings = audioTrack.underlyingTrack.getSettings();
-    const {deviceId} = settings;
+  isRealTimeTranslationEnabled: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.DISPLAY_REAL_TIME_TRANSLATION),
 
-    LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
-    LoggerProxy.logger.log(LOG_HEADER, 'settings =', JSON.stringify(settings));
-  }
-};
+  canSelectSpokenLanguages: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.DISPLAY_NON_ENGLISH_ASR),
 
-MeetingUtil.handleVideoLogging = (videoTrack: LocalCameraTrack | null) => {
-  const LOG_HEADER = 'MeetingUtil#handleVideoLogging -->';
+  waitingForOthersToJoin: (displayHints) => displayHints.includes(DISPLAY_HINTS.WAITING_FOR_OTHERS),
 
-  if (videoTrack) {
-    const settings = videoTrack.underlyingTrack.getSettings();
-    const {deviceId} = settings;
+  canSendReactions: (originalValue, displayHints) => {
+    if (displayHints.includes(DISPLAY_HINTS.REACTIONS_ACTIVE)) {
+      return true;
+    }
+    if (displayHints.includes(DISPLAY_HINTS.REACTIONS_INACTIVE)) {
+      return false;
+    }
 
-    LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
-    LoggerProxy.logger.log(LOG_HEADER, 'settings =', JSON.stringify(settings));
-  }
-};
+    return originalValue;
+  },
+  canUserRenameSelfAndObserved: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.CAN_RENAME_SELF_AND_OBSERVED),
 
-MeetingUtil.handleDeviceLogging = (devices = []) => {
-  const LOG_HEADER = 'MeetingUtil#handleDeviceLogging -->';
+  canUserRenameOthers: (displayHints) => displayHints.includes(DISPLAY_HINTS.CAN_RENAME_OTHERS),
 
-  devices.forEach((device) => {
-    LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${device.deviceId}`);
-    LoggerProxy.logger.log(LOG_HEADER, 'settings', JSON.stringify(device));
-  });
-};
+  canShareWhiteBoard: (displayHints) => displayHints.includes(DISPLAY_HINTS.SHARE_WHITEBOARD),
+
+  /**
+   * 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;
+
+    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;
+    }
+
+    const locus = response?.body?.locus;
+
+    if (locus) {
+      meeting.locusInfo.handleLocusDelta(locus, meeting);
+    }
+
+    return response;
+  },
 
-MeetingUtil.endMeetingForAll = (meeting) => {
-  if (meeting.meetingState === FULL_STATE.INACTIVE) {
-    return Promise.reject(new MeetingNotActiveError());
-  }
+  generateBuildLocusDeltaRequestOptions: (originalMeeting) => {
+    const meetingRef = new WeakRef(originalMeeting);
 
-  const endOptions = {
-    locusUrl: meeting.locusUrl,
-  };
+    const buildLocusDeltaRequestOptions = (originalOptions) => {
+      const meeting = meetingRef.deref();
 
-  return meeting.meetingRequest
-    .endMeetingForAll(endOptions)
-    .then((response) => {
-      if (response && response.body && response.body.locus) {
-        meeting.locusInfo.onFullLocus(response.body.locus);
+      if (!meeting) {
+        return originalOptions;
       }
 
-      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}`
-      );
+      const options = cloneDeep(originalOptions);
 
-      return Promise.reject(err);
-    });
-};
+      if (!options.body) {
+        options.body = {};
+      }
 
-MeetingUtil.canEnableClosedCaption = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.CAPTION_START);
+      MeetingUtil.addSequence(meeting, options.body);
 
-MeetingUtil.canStartTranscribing = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_START);
+      return options;
+    };
 
-MeetingUtil.canStopTranscribing = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_STOP);
+    return buildLocusDeltaRequestOptions;
+  },
 
-MeetingUtil.isClosedCaptionActive = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.CAPTION_STATUS_ACTIVE);
+  generateLocusDeltaRequest: (originalMeeting) => {
+    const meetingRef = new WeakRef(originalMeeting);
 
-MeetingUtil.isWebexAssistantActive = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.WEBEX_ASSISTANT_STATUS_ACTIVE);
+    const buildLocusDeltaRequestOptions =
+      MeetingUtil.generateBuildLocusDeltaRequestOptions(originalMeeting);
 
-MeetingUtil.canViewCaptionPanel = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.ENABLE_CAPTION_PANEL);
+    const locusDeltaRequest = (originalOptions) => {
+      const meeting = meetingRef.deref();
 
-MeetingUtil.isRealTimeTranslationEnabled = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.DISPLAY_REAL_TIME_TRANSLATION);
+      if (!meeting) {
+        return Promise.resolve();
+      }
 
-MeetingUtil.canSelectSpokenLanguages = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.DISPLAY_NON_ENGLISH_ASR);
+      const options = buildLocusDeltaRequestOptions(originalOptions);
 
-MeetingUtil.waitingForOthersToJoin = (displayHints) =>
-  displayHints.includes(DISPLAY_HINTS.WAITING_FOR_OTHERS);
+      return meeting
+        .request(options)
+        .then((response) => MeetingUtil.updateLocusWithDelta(meeting, response));
+    };
 
-MeetingUtil.canEnableReactions = (originalValue, displayHints) => {
-  if (displayHints.includes(DISPLAY_HINTS.ENABLE_REACTIONS)) {
-    return true;
-  }
-  if (displayHints.includes(DISPLAY_HINTS.DISABLE_REACTIONS)) {
-    return false;
-  }
+    return locusDeltaRequest;
+  },
 
-  return originalValue;
-};
+  selfSupportsFeature: (feature: SELF_POLICY, userPolicies: Record<SELF_POLICY, boolean>) => {
+    if (!userPolicies) {
+      return true;
+    }
+
+    return userPolicies[feature];
+  },
 
-MeetingUtil.canSendReactions = (originalValue, displayHints) => {
-  if (displayHints.includes(DISPLAY_HINTS.REACTIONS_ACTIVE)) {
-    return true;
-  }
-  if (displayHints.includes(DISPLAY_HINTS.REACTIONS_INACTIVE)) {
-    return false;
-  }
+  parseInterpretationInfo: (meeting, meetingInfo) => {
+    if (!meeting || !meetingInfo) {
+      return;
+    }
+    const siInfo = meetingInfo.simultaneousInterpretation;
+    meeting.simultaneousInterpretation.updateMeetingSIEnabled(
+      !!meetingInfo.turnOnSimultaneousInterpretation,
+      !!siInfo?.currentSIInterpreter
+    );
+    const hostSIEnabled = !!(
+      meetingInfo.turnOnSimultaneousInterpretation &&
+      meetingInfo?.meetingSiteSetting?.enableHostInterpreterControlSI
+    );
+    meeting.simultaneousInterpretation.updateHostSIEnabled(hostSIEnabled);
+
+    function renameKey(obj, oldKey, newKey) {
+      if (oldKey in obj) {
+        obj[newKey] = obj[oldKey];
+        delete obj[oldKey];
+      }
+    }
+    if (siInfo) {
+      const lanuagesInfo = cloneDeep(siInfo.siLanguages);
+      for (const language of lanuagesInfo) {
+        renameKey(language, 'languageCode', 'languageName');
+        renameKey(language, 'languageGroupId', 'languageCode');
+      }
+      if (!meeting.simultaneousInterpretation?.siLanguages?.length) {
+        meeting.simultaneousInterpretation.updateInterpretation({siLanguages: lanuagesInfo});
+      }
+    }
+    Trigger.trigger(
+      meeting,
+      {
+        file: 'meeting/util',
+        function: 'parseInterpretationInfo',
+      },
+      EVENT_TRIGGERS.MEETING_INTERPRETATION_UPDATE
+    );
+  },
+
+  /**
+   * Returns a CA-recognized error payload for the specified raw error message/reason.
+   *
+   * New errors can be added to this function for handling in the future
+   *
+   * @param {String} reason the raw error message
+   * @returns {Array<object>} an array of payload objects
+   */
+  getChangeMeetingFloorErrorPayload: (reason: string) => {
+    const errorPayload = {
+      errorDescription: reason,
+      name: 'locus.response',
+      shownToUser: false,
+    };
+    if (reason.includes(LOCAL_SHARE_ERRORS.UNDEFINED)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'signaling',
+          errorCode: 1100,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.DEVICE_NOT_JOINED)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'signaling',
+          errorCode: 4050,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.NO_MEDIA_FOR_DEVICE)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'media',
+          errorCode: 2048,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.NO_CONFLUENCE_ID)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'signaling',
+          errorCode: 4064,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.CONTENT_SHARING_DISABLED)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'expected',
+          errorCode: 4065,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.LOCUS_PARTICIPANT_DNE)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'signaling',
+          errorCode: 4066,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.CONTENT_REQUEST_WHILE_PENDING_WHITEBOARD)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'expected',
+          errorCode: 4067,
+        },
+      ];
+    }
 
-  return originalValue;
+    // return unknown error
+    return [
+      {
+        ...errorPayload,
+        fatal: true,
+        category: 'signaling',
+        errorCode: 1100,
+      },
+    ];
+  },
 };
 
 export default MeetingUtil;