@webex/plugin-meetings 3.12.0-next.9 → 3.12.0-next.91

package/src/meeting/locusMediaRequest.ts

@@ -1,11 +1,13 @@
 /* eslint-disable valid-jsdoc */
 import {defer} from 'lodash';
-import {Defer, transferEvents} from '@webex/common';
+import {Defer} from '@webex/common';
 import {EventEmitter} from 'events';
 import {WebexPlugin} from '@webex/webex-core';
 import {MEDIA, HTTP_VERBS, ROAP} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {ClientMediaPreferences} from '../reachability/reachability.types';
+import Metrics from '../metrics';
+import BEHAVIORAL_METRICS from '../metrics/constants';
 
 export type MediaRequestType = 'RoapMessage' | 'LocalMute';
 export type RequestResult = any;
@@ -37,13 +39,13 @@ export type Request = RoapRequest | LocalMuteRequest;
 class InternalRequestInfo {
   public readonly request: Request;
   private pendingPromises: Defer[];
-  private sendRequestFn: (request: Request) => Promise<RequestResult>;
+  private sendRequestFn: (request: Request, selfUrlRetryCount: number) => Promise<RequestResult>;
 
   /** Constructor */
   constructor(
     request: Request,
     pendingPromise: Defer,
-    sendRequestFn: (request: Request) => Promise<RequestResult>
+    sendRequestFn: (request: Request, selfUrlRetryCount: number) => Promise<RequestResult>
   ) {
     this.request = request;
     this.pendingPromises = [pendingPromise];
@@ -69,7 +71,7 @@ class InternalRequestInfo {
    * is completed (no matter if it succeeded or failed).
    */
   public execute(): Promise<void> {
-    return this.sendRequestFn(this.request)
+    return this.sendRequestFn(this.request, 0)
       .then((result) => {
         // resolve all the pending promises associated with this request
         this.pendingPromises.forEach((d) => d.resolve(result));
@@ -91,8 +93,12 @@ export type Config = {
   correlationId: string;
   meetingId: string;
   preferTranscoding: boolean;
+  getCurrentSelfUrl: () => string | undefined;
+  waitForSelfUrlChange: () => Promise<void>;
 };
 
+const MAX_SELF_URL_RETRY_COUNT = 2;
+
 /**
  * Returns true if the request is triggering confluence creation in the server
  */
@@ -194,7 +200,13 @@ export class LocusMediaRequest extends WebexPlugin {
   /**
    * Prepares the uri and body for the media request to be sent to Locus
    */
-  private sendHttpRequest(request: Request) {
+  private async sendHttpRequest(request: Request, selfUrlRetryCount = 0) {
+    // Resolve selfUrl lazily at send time. Locus rotates it on session
+    // transitions (breakout end, move-to, lobby admit) and the value
+    // captured upstream in roap/index.ts may be stale by the time we
+    // leave the queue. Persist the resolved URL on the request so a
+    // retry can detect a further rotation.
+    request.selfUrl = this.getCurrentSelfUrl(request);
     const uri = `${request.selfUrl}/${MEDIA}`;
 
     const {audioMuted, videoMuted} = this.getLatestMuteState();
@@ -263,7 +275,21 @@ export class LocusMediaRequest extends WebexPlugin {
 
         return result;
       })
-      .catch((e) => {
+      .catch(async (e) => {
+        if (
+          e?.statusCode === 409 &&
+          (await this.shouldRetryOnSelfUrlChange(request, selfUrlRetryCount))
+        ) {
+          // In-flight race: selfUrl rotated after we left the queue but
+          // before Locus rejected the request. Re-send; getCurrentSelfUrl
+          // will pick up the new URL. The returned promise replaces the
+          // rejection, so the caller's pendingPromise resolves correctly.
+          // Advance the retry count here so the guard in
+          // shouldRetryOnSelfUrlChange eventually stops after
+          // MAX_SELF_URL_RETRY_COUNT attempts.
+          return this.sendHttpRequest(request, selfUrlRetryCount + 1);
+        }
+
         if (
           isRequestAffectingConfluenceState(request) &&
           this.confluenceState === 'creation in progress'
@@ -301,6 +327,80 @@ export class LocusMediaRequest extends WebexPlugin {
     return promise;
   }
 
+  /**
+   * Returns the latest selfUrl for this meeting, falling back to the value
+   * captured when the request was enqueued.
+   */
+  private getCurrentSelfUrl(request: Request): string {
+    const currentSelfUrl = this.config.getCurrentSelfUrl();
+
+    if (currentSelfUrl && currentSelfUrl !== request.selfUrl) {
+      LoggerProxy.logger.info(
+        `Meeting:LocusMediaRequest#getCurrentSelfUrl --> resolved updated selfUrl, using ${currentSelfUrl}`
+      );
+
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.LOCUS_MEDIA_REQUEST_RETRY, {
+        correlation_id: this.config.correlationId,
+        reason: 'selfUrlUpdatedBeforeMediaRequest',
+      });
+
+      return currentSelfUrl;
+    }
+
+    return request.selfUrl;
+  }
+
+  /**
+   * Decides whether a 409 warrants a retry against the meeting's latest
+   * selfUrl.
+   */
+  private async shouldRetryOnSelfUrlChange(
+    request: Request,
+    selfUrlRetryCount: number
+  ): Promise<boolean> {
+    if (selfUrlRetryCount >= MAX_SELF_URL_RETRY_COUNT) {
+      return false;
+    }
+
+    const roapMessageType =
+      request.type === 'RoapMessage' ? request.roapMessage?.messageType : undefined;
+
+    const currentSelfUrl = this.getCurrentSelfUrl(request);
+
+    if (!currentSelfUrl || currentSelfUrl === request.selfUrl) {
+      await this.config.waitForSelfUrlChange();
+
+      const latestSelfUrl = this.getCurrentSelfUrl(request);
+
+      if (!latestSelfUrl || latestSelfUrl === request.selfUrl) {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.LOCUS_MEDIA_REQUEST_RETRY, {
+          correlation_id: this.config.correlationId,
+          reason: 'selfUrlNotChangedAfterWait',
+          retryAttempt: selfUrlRetryCount,
+          roapMessageType,
+        });
+        LoggerProxy.logger.info(
+          'Meeting:LocusMediaRequest#sendHttpRequest --> 409 conflict, no new selfUrl even after waiting'
+        );
+
+        return false;
+      }
+
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.LOCUS_MEDIA_REQUEST_RETRY, {
+        correlation_id: this.config.correlationId,
+        reason: 'selfUrlChangedAfterWait',
+        retryAttempt: selfUrlRetryCount,
+        roapMessageType,
+      });
+    }
+
+    LoggerProxy.logger.info(
+      `Meeting:LocusMediaRequest#sendHttpRequest --> 409 conflict, retrying ${request.type} with updated selfUrl`
+    );
+
+    return true;
+  }
+
   /**
    * Sends a media request to Locus
    */

package/src/meeting/muteState.ts

@@ -375,7 +375,16 @@ export class MuteState {
     }
     if (muted !== undefined) {
       this.state.server.remoteMute = muted;
-      this.muteLocalStream(meeting, muted, 'remotelyMuted');
+      // BO->Main may replay a stale remoteMute=false from the locus cache.
+      // Only enforce the mute on muted=true (also locking client.localMute so a later stale
+      // false can't flip isMuted()), and never touch the stream on muted=false — the
+      // legitimate server-driven unmute path is LOCAL_UNMUTE_REQUIRED. Always sync client
+      // intent back so other participants' tiles still show the mute icon.
+      if (muted) {
+        this.state.client.localMute = true;
+        this.muteLocalStream(meeting, true, 'remotelyMuted');
+      }
+      this.applyClientStateToServer(meeting);
     }
   }
 

package/src/meeting/request.ts

@@ -26,6 +26,7 @@ import {
   SEND_DTMF_ENDPOINT,
   _SLIDES_,
   ANNOTATION,
+  INTERPRETATION,
 } from '../constants';
 import {
   SendReactionOptions,
@@ -135,6 +136,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
     locale?: string;
     deviceCapabilities?: Array<string>;
     liveAnnotationSupported: boolean;
+    enableSimultaneousInterpretation: boolean;
     alias?: string;
     clientMediaPreferences: ClientMediaPreferences;
   }) {
@@ -158,6 +160,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       locale,
       deviceCapabilities = [],
       liveAnnotationSupported,
+      enableSimultaneousInterpretation,
       clientMediaPreferences,
       alias,
     } = options;
@@ -193,6 +196,14 @@ export default class MeetingRequest extends StatelessWebexPlugin {
     if (liveAnnotationSupported) {
       deviceCapabilities.push(ANNOTATION.ANNOTATION_ON_SHARE_SUPPORTED);
     }
+    if (enableSimultaneousInterpretation) {
+      deviceCapabilities.push(
+        INTERPRETATION.CAPABILITIES.HOST_CONTROL_SI_SUPPORTED,
+        INTERPRETATION.CAPABILITIES.INTERPRETER_CONTROL_SI_SUPPORTED,
+        INTERPRETATION.CAPABILITIES.SI_HANDOVER_SUPPORTED,
+        INTERPRETATION.CAPABILITIES.SIGN_INTERPRETER_SUPPORTED
+      );
+    }
 
     // append installationId to device config if it exists
     // @ts-ignore

package/src/meeting/util.ts

@@ -317,6 +317,7 @@ const MeetingUtil = {
         locale: options.locale,
         deviceCapabilities: options.deviceCapabilities,
         liveAnnotationSupported: options.liveAnnotationSupported,
+        enableSimultaneousInterpretation: options.enableSimultaneousInterpretation,
         clientMediaPreferences,
         alias: options.alias,
       })
@@ -371,6 +372,7 @@ const MeetingUtil = {
     meeting.breakouts.cleanUp();
     meeting.webinar.cleanUp();
     meeting.simultaneousInterpretation.cleanUp();
+    meeting.locusInfo.cleanUp();
     meeting.locusMediaRequest = undefined;
 
     meeting.webex?.internal?.newMetrics?.callDiagnosticMetrics?.clearEventLimitsForCorrelationId(
@@ -845,6 +847,19 @@ const MeetingUtil = {
     requestBody.sequence = sequence;
   },
 
+  /**
+   * Checks if Locus API response contains a Locus DTO
+   *
+   * @param {any} response http response from Locus API call
+   * @returns {boolean} true if response contains a Locus DTO
+   */
+  isLocusDtoInAPIResponse(response: any) {
+    return (
+      response?.body?.locus || // for APIs called on our participant - locus is one of props in the response body
+      response?.body?.url // for APIs that act on locus itself (like mute all), the body is the locus
+    );
+  },
+
   /**
    * Updates the locus info for the meeting with the locus
    * information returned from API requests made to Locus
@@ -853,12 +868,13 @@ const MeetingUtil = {
    * @param {Object} response The response of the http request
    * @returns {Object}
    */
-  updateLocusFromApiResponse: (meeting, response) => {
+  updateLocusFromApiResponse: (meeting: any, response: any) => {
     if (!meeting) {
       return response;
     }
 
-    if (response?.body?.locus) {
+    // locus API responses can come in different shapes:
+    if (MeetingUtil.isLocusDtoInAPIResponse(response)) {
       meeting.locusInfo.handleLocusAPIResponse(meeting, response.body);
     }
 
@@ -904,9 +920,20 @@ const MeetingUtil = {
 
       const options = buildLocusDeltaRequestOptions(originalOptions);
 
-      return meeting
-        .request(options)
-        .then((response) => MeetingUtil.updateLocusFromApiResponse(meeting, response));
+      return meeting.request(options).then((response) => {
+        const requestUri = options?.uri;
+        const meetingLocusUrl = meeting.locusUrl;
+
+        if (!requestUri || !meetingLocusUrl || !requestUri.startsWith(meetingLocusUrl)) {
+          LoggerProxy.logger.info(
+            `Meeting:util#generateLocusDeltaRequest --> skipping updateLocusFromApiResponse, request uri "${requestUri}" does not match meeting locusUrl "${meetingLocusUrl}"`
+          );
+
+          return response;
+        }
+
+        return MeetingUtil.updateLocusFromApiResponse(meeting, response);
+      });
     };
 
     return locusDeltaRequest;
@@ -930,6 +957,21 @@ const MeetingUtil = {
   attendeeRequestAiAssistantDeclinedAll: (displayHints = []) =>
     displayHints.includes(DISPLAY_HINTS.ATTENDEE_REQUEST_AI_ASSISTANT_DECLINED_ALL),
 
+  isAnonymizeDisplayNamesEnabled: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.ANONYMOUS_DISPLAY_NAMES_ENABLED),
+
+  canViewTheParticipantList: (displayHints, canNotViewTheParticipantList: boolean) => {
+    if (!displayHints.includes(DISPLAY_HINTS.VIEW_THE_PARTICIPANT_LIST)) {
+      return false;
+    }
+
+    if (canNotViewTheParticipantList) {
+      return false;
+    }
+
+    return displayHints.includes(DISPLAY_HINTS.CAN_VIEW_THE_PARTICIPANT_LIST);
+  },
+
   selfSupportsFeature: (feature: SELF_POLICY, userPolicies: Record<SELF_POLICY, boolean>) => {
     if (!userPolicies) {
       return true;

package/src/meeting-info/meeting-info-v2.ts

@@ -19,7 +19,7 @@ const ADHOC_MEETING_DEFAULT_ERROR =
 const MEETING_IS_IN_PROGRESS_MESSAGE = 'Meeting is in progress';
 const STATIC_MEETING_LINK_ALREADY_EXISTS_MESSAGE = 'Static meeting link already exists';
 const FETCH_STATIC_MEETING_LINK = 'Meeting link does not exists for conversation';
-const CAPTCHA_ERROR_REQUIRES_PASSWORD_CODES = [423005, 423006];
+const CAPTCHA_ERROR_REQUIRES_PASSWORD_CODES = [423005, 423006, 423008];
 const CAPTCHA_ERROR_REQUIRES_REGISTRATION_ID_CODES = [423007];
 
 const POLICY_ERROR_CODES = [403049, 403104, 403103, 403048, 403102, 403101];
@@ -35,7 +35,9 @@ const JOIN_FORBIDDEN_CODES = [403003];
  * 403137 - Registration ID verified failure
  *
  */
-const JOIN_WEBINAR_ERROR_CODES = [403021, 403022, 403024, 403137, 423007, 403026, 403037, 403137];
+const JOIN_WEBINAR_ERROR_CODES = [
+  403021, 403022, 403024, 403137, 423007, 403026, 403037, 403137, 403106,
+];
 
 /**
  * Error to indicate that wbxappapi requires a password