@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

package/src/meeting/util.ts

@@ -1,7 +1,9 @@
-import {LocalCameraStream, LocalMicrophoneStream} from '@webex/media-helpers';
+import {isEmpty} from 'lodash';
 
-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,
@@ -11,784 +13,518 @@ 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.'));
-    }
-
-    if (!meeting.locusMediaRequest) {
-      return Promise.reject(
-        new ParameterError(
-          'You need a meeting with a media connection, call Meeting.addMedia() first.'
-        )
-      );
-    }
-
-    // @ts-ignore
-    webex.internal.newMetrics.submitClientEvent({
-      name: 'client.locus.media.request',
-      options: {meetingId: meeting.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},
-        });
-
-        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),
+const MeetingUtil: any = {};
 
-  /**
-   * 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;
+MeetingUtil.parseLocusJoin = (response) => {
+  const parsed: any = {};
 
-    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;
-    }
-
-    if (supportsIpV4 && supportsIpV6) {
-      return IP_VERSION.ipv4_and_ipv6;
-    }
-
-    if (supportsIpV4) {
-      return IP_VERSION.only_ipv4;
-    }
+  // 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;
 
-    if (supportsIpV6) {
-      return IP_VERSION.only_ipv6;
+  // we need mediaId before making roap calls
+  parsed.mediaConnections.forEach((mediaConnection) => {
+    if (mediaConnection.mediaId) {
+      parsed.mediaId = mediaConnection.mediaId;
     }
+  });
 
-    return IP_VERSION.unknown;
-  },
+  return parsed;
+};
 
-  joinMeeting: (meeting, options) => {
-    if (!meeting) {
-      return Promise.reject(new ParameterError('You need a meeting object.'));
-    }
-    const webex = meeting.getWebexObject();
+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);
 
-    // @ts-ignore
-    webex.internal.newMetrics.submitClientEvent({
-      name: 'client.locus.join.request',
-      options: {meetingId: meeting.id},
-    });
+  if (isEmpty(localMedias)) {
+    return Promise.reject(
+      new ParameterError('You need a media id on the meeting to change remote audio.')
+    );
+  }
 
-    // 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,
-          },
-        });
+  Metrics.postEvent({event: eventType.MEDIA_REQUEST, meeting});
 
-        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 = {
+  return meeting.meetingRequest
+    .remoteAudioVideoToggle({
       locusUrl: meeting.locusUrl,
       selfId: meeting.selfId,
+      localMedias,
+      deviceUrl: meeting.deviceUrl,
       correlationId: meeting.correlationId,
-      phoneUrl,
-    };
-
-    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}`
-      );
+    })
+    .then((response) => {
+      Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meeting});
 
-      return Promise.reject(err);
+      return response.body.locus;
     });
-  },
-
-  /**
-   * 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());
-    }
-
-    if (MeetingUtil.isUserInLeftState(meeting.locusInfo)) {
-      return Promise.reject(new UserNotJoinedError());
-    }
-
-    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,
-    }),
-
-  isUserInLeftState: (locusInfo) => locusInfo.parsedLocus?.self?.state === _LEFT_,
-
-  isUserInIdleState: (locusInfo) => locusInfo.parsedLocus?.self?.state === _IDLE_,
+};
 
-  isUserInJoinedState: (locusInfo) => locusInfo.parsedLocus?.self?.state === _JOINED_,
+MeetingUtil.hasOwner = (info) => info && info.owner;
 
-  isMediaEstablished: (currentMediaStatus) =>
-    currentMediaStatus &&
-    (currentMediaStatus.audio || currentMediaStatus.video || currentMediaStatus.share),
+MeetingUtil.isOwnerSelf = (owner, selfId) => owner === selfId;
 
-  joinMeetingOptions: (meeting, options: any = {}) => {
-    const webex = meeting.getWebexObject();
+MeetingUtil.isPinOrGuest = (err) =>
+  err?.body?.errorCode && INTENT_TO_JOIN.includes(err.body.errorCode);
 
-    meeting.resourceId = meeting.resourceId || options.resourceId;
+MeetingUtil.joinMeeting = (meeting, options) => {
+  if (!meeting) {
+    return Promise.reject(new ParameterError('You need a meeting object.'));
+  }
 
-    if (meeting.requiredCaptcha) {
-      return Promise.reject(new CaptchaError());
-    }
-    if (meeting.passwordStatus === PASSWORD_STATUS.REQUIRED) {
-      return Promise.reject(new PasswordError());
-    }
+  Metrics.postEvent({event: eventType.LOCUS_JOIN_REQUEST, meeting});
 
-    if (options.pin) {
-      // @ts-ignore
-      webex.internal.newMetrics.submitClientEvent({
-        name: 'client.pin.collected',
-        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,
+      correlationId: meeting.correlationId,
+      roapMessage: options.roapMessage,
+      permissionToken: meeting.permissionToken,
+      resourceId: options.resourceId || null,
+      moderator: options.moderator,
+      pin: options.pin,
+      moveToResource: options.moveToResource,
+      preferTranscoding: options.preferTranscoding,
+      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,
         },
       });
-    }
 
-    // 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();
-    }
-
-    if (audioTracks && audioTracks.length > 0) {
-      [audioTrack] = audioTracks;
-    }
-
-    if (videoTracks && videoTracks.length > 0) {
-      [videoTrack] = videoTracks;
-    }
-
-    return {audioTrack, videoTrack};
-  },
-
-  getModeratorFromLocusInfo: (locusInfo) =>
-    locusInfo &&
-    locusInfo.parsedLocus &&
-    locusInfo.parsedLocus.info &&
-    locusInfo.parsedLocus.info &&
-    locusInfo.parsedLocus.info.moderator,
-
-  getPolicyFromLocusInfo: (locusInfo) =>
-    locusInfo &&
-    locusInfo.parsedLocus &&
-    locusInfo.parsedLocus.info &&
-    locusInfo.parsedLocus.info &&
-    locusInfo.parsedLocus.info.policy,
-
-  getUserDisplayHintsFromLocusInfo: (locusInfo) =>
-    locusInfo?.parsedLocus?.info?.userDisplayHints || [],
-
-  canInviteNewParticipants: (displayHints) => displayHints.includes(DISPLAY_HINTS.ADD_GUEST),
-
-  canAdmitParticipant: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.ROSTER_WAITING_TO_JOIN),
-
-  canUserLock: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_LOCK) &&
-    displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_UNLOCKED),
+      return MeetingUtil.parseLocusJoin(res);
+    });
+};
 
-  canUserUnlock: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_UNLOCK) &&
-    displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_LOCKED),
+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.roap.stop(meeting.correlationId, meeting.roapSeq))
+    .then(() => meeting.stopKeepAlive());
+};
 
-  canUserRaiseHand: (displayHints) => displayHints.includes(DISPLAY_HINTS.RAISE_HAND),
+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}`
+      );
 
-  canUserLowerAllHands: (displayHints) => displayHints.includes(DISPLAY_HINTS.LOWER_ALL_HANDS),
+      return Promise.reject(err);
+    });
+};
 
-  canUserLowerSomeoneElsesHand: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.LOWER_SOMEONE_ELSES_HAND),
+// 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);
+      }
 
-  bothLeaveAndEndMeetingAvailable: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.LEAVE_TRANSFER_HOST_END_MEETING) ||
-    displayHints.includes(DISPLAY_HINTS.LEAVE_END_MEETING),
+      return Promise.resolve();
+    })
+    .then(() => {
+      if (options.moveMeeting) {
+        return Promise.resolve();
+      }
 
-  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 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}`
+      );
 
-  isSuppressBreakoutSupport: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.UCF_SUPPRESS_BREAKOUTS_SUPPORT),
+      return Promise.reject(err);
+    });
+};
+MeetingUtil.declineMeeting = (meeting, reason) =>
+  meeting.meetingRequest.declineMeeting({
+    locusUrl: meeting.locusUrl,
+    deviceUrl: meeting.deviceUrl,
+    reason,
+  });
 
-  canAdmitLobbyToBreakout: (displayHints) =>
-    !displayHints.includes(DISPLAY_HINTS.DISABLE_LOBBY_TO_BREAKOUT),
+MeetingUtil.isUserInLeftState = (locusInfo) => locusInfo.parsedLocus?.self?.state === _LEFT_;
 
-  isBreakoutPreassignmentsEnabled: (displayHints) =>
-    !displayHints.includes(DISPLAY_HINTS.DISABLE_BREAKOUT_PREASSIGNMENTS),
+MeetingUtil.isUserInIdleState = (locusInfo) => locusInfo.parsedLocus?.self?.state === _IDLE_;
 
-  canUserAskForHelp: (displayHints) => !displayHints.includes(DISPLAY_HINTS.DISABLE_ASK_FOR_HELP),
+MeetingUtil.isUserInJoinedState = (locusInfo) => locusInfo.parsedLocus?.self?.state === _JOINED_;
 
-  lockMeeting: (actions, request, locusUrl) => {
-    if (actions && actions.canLock) {
-      return request.lockMeeting({locusUrl, lock: true});
-    }
+MeetingUtil.isMediaEstablished = (currentMediaStatus) =>
+  currentMediaStatus &&
+  (currentMediaStatus.audio || currentMediaStatus.video || currentMediaStatus.share);
 
-    return Promise.reject(new PermissionError('Lock not allowed, due to joined property.'));
-  },
+MeetingUtil.joinMeetingOptions = (meeting, options: any = {}) => {
+  meeting.resourceId = meeting.resourceId || options.resourceId;
 
-  unlockMeeting: (actions, request, locusUrl) => {
-    if (actions && actions.canUnlock) {
-      return request.lockMeeting({locusUrl, lock: false});
-    }
+  if (meeting.requiredCaptcha) {
+    return Promise.reject(new CaptchaError());
+  }
+  if (meeting.passwordStatus === PASSWORD_STATUS.REQUIRED) {
+    return Promise.reject(new PasswordError());
+  }
 
-    return Promise.reject(new PermissionError('Unlock not allowed, due to joined property.'));
-  },
+  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,
+        });
 
-  handleAudioLogging: (audioStream?: LocalMicrophoneStream) => {
-    const LOG_HEADER = 'MeetingUtil#handleAudioLogging -->';
+        // 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);
 
-    if (audioStream) {
-      const settings = audioStream.getSettings();
-      const {deviceId} = settings;
+      return Promise.reject(new JoinMeetingError(options, 'Error Joining Meeting', err));
+    });
+};
 
-      LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
-      LoggerProxy.logger.log(LOG_HEADER, 'settings =', JSON.stringify(settings));
-    }
-  },
+MeetingUtil.updateTransceiver = (options, meetingOptions) => {
+  const {
+    type,
+    sendTrack,
+    receiveTrack,
+    track,
+    transceiver,
+    peerConnection,
+    previousMediaDirection,
+  } = options;
+
+  if (
+    (sendTrack !== undefined && sendTrack !== previousMediaDirection.sendTrack) ||
+    (receiveTrack !== undefined && receiveTrack !== previousMediaDirection.receiveTrack)
+  ) {
+    return Media.updateTransceiver(
+      {
+        meetingId: meetingOptions.meeting.id,
+        remoteQualityLevel: meetingOptions.mediaProperties.remoteQualityLevel,
+        enableRtx: meetingOptions.meeting.config.enableRtx,
+        enableExtmap: meetingOptions.meeting.config.enableExtmap,
+      },
+      peerConnection,
+      transceiver,
+      {
+        track,
+        type,
+        receiveTrack,
+        sendTrack,
+      }
+    )
+      .then(() =>
+        meetingOptions.meeting.roap.sendRoapMediaRequest({
+          sdp: meetingOptions.mediaProperties.peerConnection.sdp,
+          roapSeq: meetingOptions.meeting.roapSeq,
+          meeting: meetingOptions.meeting, // or can pass meeting ID
+        })
+      )
+      .catch((e) => {
+        LoggerProxy.logger.error(
+          `Meeting:util#updateTransceiver --> Error updating the ${type} streams with error: ${e}`
+        );
+      });
+  }
+  if (track) {
+    transceiver.sender.replaceTrack(track);
 
-  handleVideoLogging: (videoStream?: LocalCameraStream) => {
-    const LOG_HEADER = 'MeetingUtil#handleVideoLogging -->';
+    return Promise.resolve();
+  }
 
-    if (videoStream) {
-      const settings = videoStream.getSettings();
-      const {deviceId} = settings;
+  return Promise.reject(new ParameterError('update Failed: please pass valid parameter'));
+};
 
-      LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
-      LoggerProxy.logger.log(LOG_HEADER, 'settings =', JSON.stringify(settings));
-    }
-  },
+MeetingUtil.validateOptions = (options) => {
+  const {sendVideo, sendAudio, sendShare, localStream, localShare} = options;
 
-  handleDeviceLogging: (devices = []) => {
-    const LOG_HEADER = 'MeetingUtil#handleDeviceLogging -->';
+  if (sendVideo && !MeetingUtil.getTrack(localStream).videoTrack) {
+    return Promise.reject(new ParameterError('please pass valid video streams'));
+  }
 
-    devices.forEach((device) => {
-      LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${device.deviceId}`);
-      LoggerProxy.logger.log(LOG_HEADER, 'settings', JSON.stringify(device));
-    });
-  },
+  if (sendAudio && !MeetingUtil.getTrack(localStream).audioTrack) {
+    return Promise.reject(new ParameterError('please pass valid audio streams'));
+  }
 
-  endMeetingForAll: (meeting) => {
-    if (meeting.meetingState === FULL_STATE.INACTIVE) {
-      return Promise.reject(new MeetingNotActiveError());
-    }
+  if (sendShare && !MeetingUtil.getTrack(localShare).videoTrack) {
+    return Promise.reject(new ParameterError('please pass valid share streams'));
+  }
 
-    const endOptions = {
-      locusUrl: meeting.locusUrl,
-    };
+  return Promise.resolve();
+};
 
-    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.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};
+};
 
-        return Promise.reject(err);
-      });
-  },
+MeetingUtil.getModeratorFromLocusInfo = (locusInfo) =>
+  locusInfo &&
+  locusInfo.parsedLocus &&
+  locusInfo.parsedLocus.info &&
+  locusInfo.parsedLocus.info &&
+  locusInfo.parsedLocus.info.moderator;
 
-  canEnableClosedCaption: (displayHints) => displayHints.includes(DISPLAY_HINTS.CAPTION_START),
+MeetingUtil.getPolicyFromLocusInfo = (locusInfo) =>
+  locusInfo &&
+  locusInfo.parsedLocus &&
+  locusInfo.parsedLocus.info &&
+  locusInfo.parsedLocus.info &&
+  locusInfo.parsedLocus.info.policy;
 
-  isSaveTranscriptsEnabled: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.SAVE_TRANSCRIPTS_ENABLED),
+MeetingUtil.getUserDisplayHintsFromLocusInfo = (locusInfo) =>
+  locusInfo?.parsedLocus?.info?.userDisplayHints || [];
 
-  canStartTranscribing: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_START),
+MeetingUtil.canInviteNewParticipants = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.ADD_GUEST);
 
-  canStopTranscribing: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_STOP),
+MeetingUtil.canAdmitParticipant = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.ROSTER_WAITING_TO_JOIN);
 
-  isClosedCaptionActive: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.CAPTION_STATUS_ACTIVE),
+MeetingUtil.canUserLock = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_LOCK) &&
+  displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_UNLOCKED);
 
-  isWebexAssistantActive: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.WEBEX_ASSISTANT_STATUS_ACTIVE),
+MeetingUtil.canUserUnlock = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_UNLOCK) &&
+  displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_LOCKED);
 
-  canViewCaptionPanel: (displayHints) => displayHints.includes(DISPLAY_HINTS.ENABLE_CAPTION_PANEL),
+MeetingUtil.canUserRaiseHand = (displayHints) => displayHints.includes(DISPLAY_HINTS.RAISE_HAND);
 
-  isRealTimeTranslationEnabled: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.DISPLAY_REAL_TIME_TRANSLATION),
+MeetingUtil.canUserLowerAllHands = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.LOWER_ALL_HANDS);
 
-  canSelectSpokenLanguages: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.DISPLAY_NON_ENGLISH_ASR),
+MeetingUtil.canUserLowerSomeoneElsesHand = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.LOWER_SOMEONE_ELSES_HAND);
 
-  waitingForOthersToJoin: (displayHints) => displayHints.includes(DISPLAY_HINTS.WAITING_FOR_OTHERS),
+MeetingUtil.bothLeaveAndEndMeetingAvailable = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.LEAVE_TRANSFER_HOST_END_MEETING) ||
+  displayHints.includes(DISPLAY_HINTS.LEAVE_END_MEETING);
 
-  canSendReactions: (originalValue, displayHints) => {
-    if (displayHints.includes(DISPLAY_HINTS.REACTIONS_ACTIVE)) {
-      return true;
-    }
-    if (displayHints.includes(DISPLAY_HINTS.REACTIONS_INACTIVE)) {
-      return false;
-    }
+MeetingUtil.lockMeeting = (actions, request, locusUrl) => {
+  if (actions && actions.canLock) {
+    return request.lockMeeting({locusUrl, lock: true});
+  }
 
-    return originalValue;
-  },
-  canUserRenameSelfAndObserved: (displayHints) =>
-    displayHints.includes(DISPLAY_HINTS.CAN_RENAME_SELF_AND_OBSERVED),
+  return Promise.reject(new PermissionError('Lock not allowed, due to joined property.'));
+};
 
-  canUserRenameOthers: (displayHints) => displayHints.includes(DISPLAY_HINTS.CAN_RENAME_OTHERS),
+MeetingUtil.unlockMeeting = (actions, request, locusUrl) => {
+  if (actions && actions.canUnlock) {
+    return request.lockMeeting({locusUrl, lock: false});
+  }
 
-  canShareWhiteBoard: (displayHints) => displayHints.includes(DISPLAY_HINTS.SHARE_WHITEBOARD),
+  return Promise.reject(new PermissionError('Unlock not allowed, due to joined property.'));
+};
 
-  /**
-   * 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.handleAudioLogging = (audioTrack) => {
+  const LOG_HEADER = 'MeetingUtil#handleAudioLogging -->';
 
-    if (!sequence) {
-      return;
-    }
+  if (audioTrack) {
+    const settings = audioTrack.getSettings();
+    const {deviceId} = settings;
 
-    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;
-    }
+    LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
+    LoggerProxy.logger.log(LOG_HEADER, 'settings =', JSON.stringify(settings));
+  }
+};
 
-    const locus = response?.body?.locus;
+MeetingUtil.handleVideoLogging = (videoTrack) => {
+  const LOG_HEADER = 'MeetingUtil#handleVideoLogging -->';
 
-    if (locus) {
-      meeting.locusInfo.handleLocusDelta(locus, meeting);
-    }
+  if (videoTrack) {
+    const settings = videoTrack.getSettings();
+    const {deviceId} = settings;
 
-    return response;
-  },
+    LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${deviceId}`);
+    LoggerProxy.logger.log(LOG_HEADER, 'settings =', JSON.stringify(settings));
+  }
+};
 
-  generateBuildLocusDeltaRequestOptions: (originalMeeting) => {
-    const meetingRef = new WeakRef(originalMeeting);
+MeetingUtil.handleDeviceLogging = (devices = []) => {
+  const LOG_HEADER = 'MeetingUtil#handleDeviceLogging -->';
 
-    const buildLocusDeltaRequestOptions = (originalOptions) => {
-      const meeting = meetingRef.deref();
+  devices.forEach((device) => {
+    LoggerProxy.logger.log(LOG_HEADER, `deviceId = ${device.deviceId}`);
+    LoggerProxy.logger.log(LOG_HEADER, 'settings', JSON.stringify(device));
+  });
+};
 
-      if (!meeting) {
-        return originalOptions;
-      }
+MeetingUtil.endMeetingForAll = (meeting) => {
+  if (meeting.meetingState === FULL_STATE.INACTIVE) {
+    return Promise.reject(new MeetingNotActiveError());
+  }
 
-      const options = cloneDeep(originalOptions);
+  const endOptions = {
+    locusUrl: meeting.locusUrl,
+  };
 
-      if (!options.body) {
-        options.body = {};
+  return meeting.meetingRequest
+    .endMeetingForAll(endOptions)
+    .then((response) => {
+      if (response && response.body && response.body.locus) {
+        meeting.locusInfo.onFullLocus(response.body.locus);
       }
 
-      MeetingUtil.addSequence(meeting, options.body);
-
-      return options;
-    };
-
-    return buildLocusDeltaRequestOptions;
-  },
-
-  generateLocusDeltaRequest: (originalMeeting) => {
-    const meetingRef = new WeakRef(originalMeeting);
+      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 buildLocusDeltaRequestOptions =
-      MeetingUtil.generateBuildLocusDeltaRequestOptions(originalMeeting);
+      return Promise.reject(err);
+    });
+};
 
-    const locusDeltaRequest = (originalOptions) => {
-      const meeting = meetingRef.deref();
+MeetingUtil.canEnableClosedCaption = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.CAPTION_START);
 
-      if (!meeting) {
-        return Promise.resolve();
-      }
+MeetingUtil.canStartTranscribing = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_START);
 
-      const options = buildLocusDeltaRequestOptions(originalOptions);
+MeetingUtil.canStopTranscribing = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_STOP);
 
-      return meeting
-        .request(options)
-        .then((response) => MeetingUtil.updateLocusWithDelta(meeting, response));
-    };
+MeetingUtil.isClosedCaptionActive = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.CAPTION_STATUS_ACTIVE);
 
-    return locusDeltaRequest;
-  },
+MeetingUtil.isWebexAssistantActive = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.WEBEX_ASSISTANT_STATUS_ACTIVE);
 
-  selfSupportsFeature: (feature: SELF_POLICY, userPolicies: Record<SELF_POLICY, boolean>) => {
-    if (!userPolicies) {
-      return true;
-    }
+MeetingUtil.canViewCaptionPanel = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.ENABLE_CAPTION_PANEL);
 
-    return userPolicies[feature];
-  },
+MeetingUtil.isRealTimeTranslationEnabled = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.DISPLAY_REAL_TIME_TRANSLATION);
 
-  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);
+MeetingUtil.canSelectSpokenLanguages = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.DISPLAY_NON_ENGLISH_ASR);
 
-    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 unknown error
-    return [
-      {
-        ...errorPayload,
-        fatal: true,
-        category: 'signaling',
-        errorCode: 1100,
-      },
-    ];
-  },
-};
+MeetingUtil.waitingForOthersToJoin = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.WAITING_FOR_OTHERS);
 
 export default MeetingUtil;