@webex/plugin-meetings 3.8.1-web-workers-keepalive.1 → 3.9.0-next.1

package/src/meeting/index.ts

@@ -121,6 +121,7 @@ import {
   WEBINAR_ERROR_REGISTRATION_ID,
   JOIN_BEFORE_HOST,
   REGISTRATION_ID_STATUS,
+  STAGE_MANAGER_TYPE,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ParameterError from '../common/errors/parameter';
@@ -164,6 +165,8 @@ import {BrbState, createBrbState} from './brbState';
 import MultistreamNotSupportedError from '../common/errors/multistream-not-supported-error';
 import JoinForbiddenError from '../common/errors/join-forbidden-error';
 import {ReachabilityMetrics} from '../reachability/reachability.types';
+import {SetStageOptions, SetStageVideoLayout, UnsetStageVideoLayout} from './request.type';
+import {Invitee} from './type';
 
 // default callback so we don't call an undefined function, but in practice it should never be used
 const DEFAULT_ICE_PHASE_CALLBACK = () => 'JOIN_MEETING_FINAL';
@@ -248,6 +251,7 @@ export type CallStateForMetrics = {
   loginType?: string;
   userNameInput?: string;
   emailInput?: string;
+  pstnCorrelationId?: string;
 };
 
 export const MEDIA_UPDATE_TYPE = {
@@ -741,10 +745,11 @@ export default class Meeting extends StatelessWebexPlugin {
   /**
    * @param {Object} attrs
    * @param {Object} options
+   * @param {Function} callback - if provided, it will be called with the newly created meeting object as soon as the meeting.id is set
    * @constructor
    * @memberof Meeting
    */
-  constructor(attrs: any, options: object) {
+  constructor(attrs: any, options: object, callback: (meeting: Meeting) => void) {
     super({}, options);
     /**
      * @instance
@@ -770,6 +775,11 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     this.id = uuid.v4();
+
+    if (callback) {
+      callback(this);
+    }
+
     /**
      * Call state used for metrics
      * @instance
@@ -1674,6 +1684,22 @@ export default class Meeting extends StatelessWebexPlugin {
     this.callStateForMetrics.correlationId = correlationId;
   }
 
+  /**
+   * Getter - Returns callStateForMetrics.pstnCorrelationId
+   * @returns {string | undefined}
+   */
+  get pstnCorrelationId(): string | undefined {
+    return this.callStateForMetrics.pstnCorrelationId;
+  }
+
+  /**
+   * Setter - sets callStateForMetrics.pstnCorrelationId
+   * @param {string | undefined} correlationId
+   */
+  set pstnCorrelationId(correlationId: string | undefined) {
+    this.callStateForMetrics.pstnCorrelationId = correlationId;
+  }
+
   /**
    * Getter - Returns callStateForMetrics.userNameInput
    * @returns {string}
@@ -3056,12 +3082,16 @@ export default class Meeting extends StatelessWebexPlugin {
       // There is no concept of local/remote share for whiteboard
       // It does not matter who requested to share the whiteboard, everyone gets the same view
       else if (whiteboardShare.disposition === FLOOR_ACTION.GRANTED) {
-        // WHITEBOARD - sharing whiteboard
-        // Webinar attendee should receive whiteboard as remote share
-        newShareStatus =
-          this.locusInfo?.info?.isWebinar && this.webinar?.selfIsAttendee
-            ? SHARE_STATUS.REMOTE_SHARE_ACTIVE
-            : SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE;
+        if (this.locusInfo?.info?.isWebinar && this.webinar?.selfIsAttendee) {
+          // WHITEBOARD - sharing whiteboard
+          // Webinar attendee should receive whiteboard as remote share
+          newShareStatus = SHARE_STATUS.REMOTE_SHARE_ACTIVE;
+        } else if (this.guest) {
+          // If user is a guest to a meeting, they should receive whiteboard as remote share
+          newShareStatus = SHARE_STATUS.REMOTE_SHARE_ACTIVE;
+        } else {
+          newShareStatus = SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE;
+        }
       }
       // or if content share is either released or null and whiteboard share is either released or null, no one is sharing
       else if (
@@ -3827,49 +3857,44 @@ export default class Meeting extends StatelessWebexPlugin {
 
   /**
    * Invite a guest to the call that isn't normally part of this call
-   * @param {Object} invitee
+   * @param {Invitee} invitee
    * @param {String} invitee.emailAddress
    * @param {String} invitee.email
    * @param {String} invitee.phoneNumber
    * @param {Boolean} [alertIfActive]
+   * @param {Boolean} [invitee.skipEmailValidation]
+   * @param {Boolean} [invitee.isInternalNumber]
    * @returns {Promise} see #members.addMember
    * @public
    * @memberof Meeting
    */
-  public invite(
-    invitee: {
-      emailAddress: string;
-      email: string;
-      phoneNumber: string;
-      roles: Array<string>;
-    },
-    alertIfActive = true
-  ) {
+  public invite(invitee: Invitee, alertIfActive = true) {
     return this.members.addMember(invitee, alertIfActive);
   }
 
   /**
    * Cancel an outgoing phone call invitation made during a meeting
-   * @param {Object} invitee
+   * @param {Invitee} invitee
    * @param {String} invitee.phoneNumber
    * @returns {Promise} see #members.cancelPhoneInvite
    * @public
    * @memberof Meeting
    */
-  public cancelPhoneInvite(invitee: {phoneNumber: string}) {
+  public cancelPhoneInvite(invitee: Invitee) {
     return this.members.cancelPhoneInvite(invitee);
   }
 
   /**
-   * Cancel an SIP call invitation made during a meeting
-   * @param {Object} invitee
+   * Cancel an SIP/phone call invitation made during a meeting
+   * @param {Invitee} invitee
    * @param {String} invitee.memberId
-   * @returns {Promise} see #members.cancelSIPInvite
+   * @param {Boolean} [invitee.isInternalNumber] - When cancel phone invitation, if the number is internal
+   * @returns {Promise} see #members.cancelInviteByMemberId
    * @public
    * @memberof Meeting
    */
-  public cancelSIPInvite(invitee: {memberId: string}) {
-    return this.members.cancelSIPInvite(invitee);
+  public cancelInviteByMemberId(invitee: Invitee) {
+    return this.members.cancelInviteByMemberId(invitee);
   }
 
   /**
@@ -4167,6 +4192,9 @@ export default class Meeting extends StatelessWebexPlugin {
           isClosedCaptionActive: MeetingUtil.isClosedCaptionActive(this.userDisplayHints),
           canStartManualCaption: MeetingUtil.canStartManualCaption(this.userDisplayHints),
           canStopManualCaption: MeetingUtil.canStopManualCaption(this.userDisplayHints),
+          isLocalRecordingStarted: MeetingUtil.isLocalRecordingStarted(this.userDisplayHints),
+          isLocalRecordingStopped: MeetingUtil.isLocalRecordingStopped(this.userDisplayHints),
+          isLocalRecordingPaused: MeetingUtil.isLocalRecordingPaused(this.userDisplayHints),
           isManualCaptionActive: MeetingUtil.isManualCaptionActive(this.userDisplayHints),
           isSaveTranscriptsEnabled: MeetingUtil.isSaveTranscriptsEnabled(this.userDisplayHints),
           isWebexAssistantActive: MeetingUtil.isWebexAssistantActive(this.userDisplayHints),
@@ -5924,15 +5952,6 @@ export default class Meeting extends StatelessWebexPlugin {
         this.meetingFiniteStateMachine.fail(error);
         LoggerProxy.logger.error('Meeting:index#join --> Failed', error);
 
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.locus.join.response',
-          payload: {
-            identifiers: {meetingLookupUrl: this.meetingInfo?.meetingLookupUrl},
-          },
-          options: {meetingId: this.id, rawError: error},
-        });
-
         // TODO:  change this to error codes and pre defined dictionary
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.JOIN_FAILURE, {
           correlation_id: this.correlationId,
@@ -6082,8 +6101,9 @@ export default class Meeting extends StatelessWebexPlugin {
    */
   private dialInPstn() {
     if (this.isPhoneProvisioned(this.dialInDeviceStatus)) return Promise.resolve(); // prevent multiple dial in devices from being provisioned
+    this.pstnCorrelationId = uuid.v4();
 
-    const {correlationId, locusUrl} = this;
+    const {pstnCorrelationId, locusUrl} = this;
 
     if (!this.dialInUrl) this.dialInUrl = `dialin:///${uuid.v4()}`;
 
@@ -6091,7 +6111,7 @@ export default class Meeting extends StatelessWebexPlugin {
       this.meetingRequest
         // @ts-ignore
         .dialIn({
-          correlationId,
+          correlationId: pstnCorrelationId,
           dialInUrl: this.dialInUrl,
           locusUrl,
           clientUrl: this.deviceUrl,
@@ -6100,12 +6120,17 @@ export default class Meeting extends StatelessWebexPlugin {
           Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_DIAL_IN_FAILURE, {
             correlation_id: this.correlationId,
             dial_in_url: this.dialInUrl,
+            dial_in_correlation_id: pstnCorrelationId,
             locus_id: locusUrl.split('/').pop(),
             client_url: this.deviceUrl,
             reason: error.error?.message,
             stack: error.stack,
           });
 
+          if (this.pstnCorrelationId === pstnCorrelationId) {
+            this.pstnCorrelationId = undefined;
+          }
+
           return Promise.reject(error);
         })
     );
@@ -6120,8 +6145,9 @@ export default class Meeting extends StatelessWebexPlugin {
    */
   private dialOutPstn(phoneNumber: string) {
     if (this.isPhoneProvisioned(this.dialOutDeviceStatus)) return Promise.resolve(); // prevent multiple dial out devices from being provisioned
+    this.pstnCorrelationId = uuid.v4();
 
-    const {correlationId, locusUrl} = this;
+    const {locusUrl, pstnCorrelationId} = this;
 
     if (!this.dialOutUrl) this.dialOutUrl = `dialout:///${uuid.v4()}`;
 
@@ -6129,7 +6155,7 @@ export default class Meeting extends StatelessWebexPlugin {
       this.meetingRequest
         // @ts-ignore
         .dialOut({
-          correlationId,
+          correlationId: pstnCorrelationId,
           dialOutUrl: this.dialOutUrl,
           phoneNumber,
           locusUrl,
@@ -6139,12 +6165,17 @@ export default class Meeting extends StatelessWebexPlugin {
           Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADD_DIAL_OUT_FAILURE, {
             correlation_id: this.correlationId,
             dial_out_url: this.dialOutUrl,
+            dial_out_correlation_id: pstnCorrelationId,
             locus_id: locusUrl.split('/').pop(),
             client_url: this.deviceUrl,
             reason: error.error?.message,
             stack: error.stack,
           });
 
+          if (this.pstnCorrelationId === pstnCorrelationId) {
+            this.pstnCorrelationId = undefined;
+          }
+
           return Promise.reject(error);
         })
     );
@@ -6158,6 +6189,8 @@ export default class Meeting extends StatelessWebexPlugin {
    * @returns {Promise}
    */
   public disconnectPhoneAudio() {
+    const correlationToClear = this.pstnCorrelationId;
+
     return Promise.all([
       this.isPhoneProvisioned(this.dialInDeviceStatus)
         ? MeetingUtil.disconnectPhoneAudio(this, this.dialInUrl)
@@ -6165,7 +6198,11 @@ export default class Meeting extends StatelessWebexPlugin {
       this.isPhoneProvisioned(this.dialOutDeviceStatus)
         ? MeetingUtil.disconnectPhoneAudio(this, this.dialOutUrl)
         : Promise.resolve(),
-    ]);
+    ]).then(() => {
+      if (this.pstnCorrelationId === correlationToClear) {
+        this.pstnCorrelationId = undefined;
+      }
+    });
   }
 
   /**
@@ -8387,6 +8424,10 @@ export default class Meeting extends StatelessWebexPlugin {
     }
 
     if (whiteboard) {
+      // @ts-ignore
+      this.webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp({
+        key: 'internal.client.share.initiated',
+      });
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.share.initiated',
@@ -8446,11 +8487,17 @@ export default class Meeting extends StatelessWebexPlugin {
     const whiteboard = this.locusInfo.mediaShares.find((element) => element.name === 'whiteboard');
 
     if (whiteboard) {
+      // @ts-ignore
+      this.webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp({
+        key: 'internal.client.share.stopped',
+      });
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.share.stopped',
         payload: {
           mediaType: 'whiteboard',
+          // @ts-ignore
+          shareDuration: this.webex.internal.newMetrics.callDiagnosticLatencies.getShareDuration(),
         },
         options: {
           meetingId: this.id,
@@ -8608,12 +8655,18 @@ export default class Meeting extends StatelessWebexPlugin {
     }
     this.screenShareFloorState = ScreenShareFloorStatus.RELEASED;
     if (content) {
+      // @ts-ignore
+      this.webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp({
+        key: 'internal.client.share.stopped',
+      });
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.share.stopped',
         payload: {
           mediaType: 'share',
           shareInstanceId: this.localShareInstanceId,
+          // @ts-ignore
+          shareDuration: this.webex.internal.newMetrics.callDiagnosticLatencies.getShareDuration(),
         },
         options: {meetingId: this.id},
       });
@@ -9590,6 +9643,11 @@ export default class Meeting extends StatelessWebexPlugin {
       this.shareCAEventSentStatus.transmitStart = false;
       this.shareCAEventSentStatus.transmitStop = false;
 
+      // @ts-ignore
+      this.webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp({
+        key: 'internal.client.share.initiated',
+      });
+
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.share.initiated',
@@ -9763,4 +9821,73 @@ export default class Meeting extends StatelessWebexPlugin {
       selected_subnet: selectedSubnetFirstOctet ? `${selectedSubnetFirstOctet}.X.X.X` : null,
     };
   }
+
+  /**
+   * Set the stage for the meeting
+   *
+   * @param {SetStageOptions} options Options to use when setting the stage
+   * @returns {Promise} The locus request
+   */
+  setStage({
+    activeSpeakerProportion = 0.5,
+    customBackground,
+    customLogo,
+    customNameLabel,
+    importantParticipants,
+    lockAttendeeViewOnStage = false,
+    showActiveSpeaker = false,
+  }: SetStageOptions = {}) {
+    const videoLayout: SetStageVideoLayout = {
+      overrideDefault: true,
+      lockAttendeeViewOnStageOnly: lockAttendeeViewOnStage,
+      stageParameters: {
+        activeSpeakerProportion,
+        showActiveSpeaker: {show: showActiveSpeaker, order: 0},
+        stageManagerType: 0,
+      },
+    };
+
+    if (importantParticipants?.length) {
+      videoLayout.stageParameters.importantParticipants = importantParticipants.map(
+        (importantParticipant, index) => ({...importantParticipant, order: index + 1})
+      );
+    }
+
+    if (customLogo) {
+      if (!videoLayout.customLayouts) {
+        videoLayout.customLayouts = {};
+      }
+      videoLayout.customLayouts.logo = customLogo;
+      // eslint-disable-next-line no-bitwise
+      videoLayout.stageParameters.stageManagerType |= STAGE_MANAGER_TYPE.LOGO;
+    }
+
+    if (customBackground) {
+      if (!videoLayout.customLayouts) {
+        videoLayout.customLayouts = {};
+      }
+      videoLayout.customLayouts.background = customBackground;
+      // eslint-disable-next-line no-bitwise
+      videoLayout.stageParameters.stageManagerType |= STAGE_MANAGER_TYPE.BACKGROUND;
+    }
+
+    if (customNameLabel) {
+      videoLayout.nameLabelStyle = customNameLabel;
+      // eslint-disable-next-line no-bitwise
+      videoLayout.stageParameters.stageManagerType |= STAGE_MANAGER_TYPE.NAME_LABEL;
+    }
+
+    return this.meetingRequest.synchronizeStage(this.locusUrl, videoLayout);
+  }
+
+  /**
+   * Unset the stage for the meeting
+   *
+   * @returns {Promise} The locus request
+   */
+  unsetStage() {
+    const videoLayout: UnsetStageVideoLayout = {overrideDefault: false};
+
+    return this.meetingRequest.synchronizeStage(this.locusUrl, videoLayout);
+  }
 }

package/src/meeting/request.ts

@@ -32,6 +32,7 @@ import {
   BrbOptions,
   ToggleReactionsOptions,
   PostMeetingDataConsentOptions,
+  SynchronizeVideoLayout,
 } from './request.type';
 import MeetingUtil from './util';
 import {AnnotationInfo} from '../annotation/annotation.types';
@@ -969,4 +970,19 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       },
     });
   }
+
+  /**
+   * Synchronize the stage for a meeting
+   *
+   * @param {LocusUrl} locusUrl The locus URL
+   * @param {SetStageVideoLayout} videoLayout The video layout to synchronize
+   * @returns {Promise} The locus request
+   */
+  synchronizeStage(locusUrl: string, videoLayout: SynchronizeVideoLayout) {
+    return this.locusDeltaRequest({
+      method: HTTP_VERBS.PATCH,
+      uri: `${locusUrl}/${CONTROLS}`,
+      body: {videoLayout},
+    });
+  }
 }

package/src/meeting/request.type.ts

@@ -25,3 +25,67 @@ export type PostMeetingDataConsentOptions = {
   deviceUrl: string;
   selfId: string;
 };
+
+export type StageCustomLogoPositions =
+  | 'LowerLeft'
+  | 'LowerMiddle'
+  | 'LowerRight'
+  | 'UpperLeft'
+  | 'UpperMiddle'
+  | 'UpperRight';
+
+export type StageNameLabelType = 'Primary' | 'PrimaryInverted' | 'Secondary' | 'SecondaryInverted';
+
+export type StageCustomBackground = {
+  url: string;
+  [others: string]: unknown;
+};
+
+export type StageCustomLogo = {
+  url: string;
+  position: StageCustomLogoPositions;
+  [others: string]: unknown;
+};
+
+export type StageCustomNameLabel = {
+  accentColor: string;
+  background: {color: string};
+  border: {color: string};
+  content: {displayName: {color: string}; subtitle: {color: string}};
+  decoration: {color: string};
+  fadeOut?: {delay: number};
+  type: StageNameLabelType;
+  [others: string]: unknown;
+};
+
+export type SetStageOptions = {
+  activeSpeakerProportion?: number;
+  customBackground?: StageCustomBackground;
+  customLogo?: StageCustomLogo;
+  customNameLabel?: StageCustomNameLabel;
+  importantParticipants?: {mainCsi: number; participantId: string}[];
+  lockAttendeeViewOnStage?: boolean;
+  showActiveSpeaker?: boolean;
+};
+
+export type SetStageVideoLayout = {
+  overrideDefault: true;
+  lockAttendeeViewOnStageOnly: boolean;
+  stageParameters: {
+    importantParticipants?: {participantId: string; mainCsi: number; order: number}[];
+    showActiveSpeaker: {show: boolean; order: number};
+    activeSpeakerProportion: number;
+    stageManagerType: number;
+  };
+  customLayouts?: {
+    background?: StageCustomBackground;
+    logo?: StageCustomLogo;
+  };
+  nameLabelStyle?: StageCustomNameLabel;
+};
+
+export type UnsetStageVideoLayout = {
+  overrideDefault: false;
+};
+
+export type SynchronizeVideoLayout = SetStageVideoLayout | UnsetStageVideoLayout;

package/src/meeting/type.ts

@@ -0,0 +1,9 @@
+export type Invitee = {
+  memberId: string;
+  emailAddress: string;
+  email: string;
+  phoneNumber: string;
+  roles: Array<string>;
+  skipEmailValidation?: boolean;
+  isInternalNumber?: boolean;
+};

package/src/meeting/util.ts

@@ -197,6 +197,17 @@ const MeetingUtil = {
         });
 
         return parsed;
+      })
+      .catch((err) => {
+        webex.internal.newMetrics.submitClientEvent({
+          name: 'client.locus.join.response',
+          payload: {
+            identifiers: {meetingLookupUrl: meeting.meetingInfo?.meetingLookupUrl},
+          },
+          options: {meetingId: meeting.id, rawError: err},
+        });
+
+        throw err;
       });
   },
 
@@ -208,6 +219,10 @@ const MeetingUtil = {
     meeting.simultaneousInterpretation.cleanUp();
     meeting.locusMediaRequest = undefined;
 
+    meeting.webex?.internal?.newMetrics?.callDiagnosticMetrics?.clearEventLimitsForCorrelationId(
+      meeting.correlationId
+    );
+
     // make sure we send last metrics before we close the peerconnection
     const stopStatsAnalyzer = meeting.statsAnalyzer
       ? meeting.statsAnalyzer.stopAnalyzer()
@@ -328,10 +343,57 @@ const MeetingUtil = {
     meeting.resourceId = meeting.resourceId || options.resourceId;
 
     if (meeting.requiredCaptcha) {
-      return Promise.reject(new CaptchaError());
+      const errorToThrow = new CaptchaError();
+
+      // @ts-ignore
+      webex.internal.newMetrics.submitClientEvent({
+        name: 'client.meetinginfo.response',
+        options: {
+          meetingId: meeting.id,
+        },
+        payload: {
+          errors: [
+            {
+              fatal: false,
+              category: 'expected',
+              name: 'other',
+              shownToUser: false,
+              errorCode: errorToThrow.code,
+              errorDescription: errorToThrow.name,
+              rawErrorMessage: errorToThrow.sdkMessage,
+            },
+          ],
+        },
+      });
+
+      return Promise.reject(errorToThrow);
     }
+
     if (meeting.passwordStatus === PASSWORD_STATUS.REQUIRED) {
-      return Promise.reject(new PasswordError());
+      const errorToThrow = new PasswordError();
+
+      // @ts-ignore
+      webex.internal.newMetrics.submitClientEvent({
+        name: 'client.meetinginfo.response',
+        options: {
+          meetingId: meeting.id,
+        },
+        payload: {
+          errors: [
+            {
+              fatal: false,
+              category: 'expected',
+              name: 'other',
+              shownToUser: false,
+              errorCode: errorToThrow.code,
+              errorDescription: errorToThrow.name,
+              rawErrorMessage: errorToThrow.sdkMessage,
+            },
+          ],
+        },
+      });
+
+      return Promise.reject(errorToThrow);
     }
 
     if (options.pin) {
@@ -542,6 +604,15 @@ const MeetingUtil = {
   canStartManualCaption: (displayHints) =>
     displayHints.includes(DISPLAY_HINTS.MANUAL_CAPTION_START),
 
+  isLocalRecordingStarted: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LOCAL_RECORDING_STATUS_STARTED),
+
+  isLocalRecordingStopped: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LOCAL_RECORDING_STATUS_STOPPED),
+
+  isLocalRecordingPaused: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LOCAL_RECORDING_STATUS_PAUSED),
+
   canStopManualCaption: (displayHints) => displayHints.includes(DISPLAY_HINTS.MANUAL_CAPTION_STOP),
 
   isManualCaptionActive: (displayHints) =>

package/src/meetings/index.ts

@@ -1560,11 +1560,12 @@ export default class Meetings extends WebexPlugin {
       {
         // @ts-ignore
         parent: this.webex,
+      },
+      (newMeeting) => {
+        this.meetingCollection.set(newMeeting);
       }
     );
 
-    this.meetingCollection.set(meeting);
-
     try {
       // if no participant has joined the scheduled meeting (meaning meeting is not active) and we get a locusEvent,
       // it means the meeting will start in 5-6 min. In that case, we want to fetchMeetingInfo

package/src/member/index.ts

@@ -3,6 +3,7 @@
  */
 import {MEETINGS, _IN_LOBBY_, _NOT_IN_MEETING_, _IN_MEETING_, _OBSERVE_} from '../constants';
 import {IExternalRoles, IMediaStatus, Participant, ParticipantUrl} from './types';
+
 import MemberUtil from './util';
 
 export type MemberId = string;