@webex/plugin-meetings 3.11.0 → 3.12.0-mobius-socket.1

package/src/multistream/mediaRequestManager.ts

@@ -10,7 +10,7 @@ import {
   RecommendedOpusBitrates,
   NamedMediaGroup,
 } from '@webex/internal-media-core';
-import {cloneDeepWith, debounce, isEmpty} from 'lodash';
+import {cloneDeepWith, debounce} from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 
@@ -94,8 +94,6 @@ export class MediaRequestManager {
 
   private debouncedSourceUpdateListener: () => void;
 
-  private previousStreamRequests: Array<StreamRequest> = [];
-
   private trimRequestsToNumOfSources: boolean;
   private numTotalSources: number;
   private numLiveSources: number;
@@ -161,36 +159,6 @@ export class MediaRequestManager {
     }
   }
 
-  /**
-   * Returns true if two stream requests are the same, false otherwise.
-   *
-   * @param {StreamRequest} streamRequestA - Stream request A for comparison.
-   * @param {StreamRequest} streamRequestB - Stream request B for comparison.
-   * @returns {boolean} - Whether they are equal.
-   */
-  // eslint-disable-next-line class-methods-use-this
-  public isEqual(streamRequestA: StreamRequest, streamRequestB: StreamRequest) {
-    return (
-      JSON.stringify(streamRequestA._toJmpStreamRequest()) ===
-      JSON.stringify(streamRequestB._toJmpStreamRequest())
-    );
-  }
-
-  /**
-   * Compares new stream requests to previous ones and determines
-   * if they are the same.
-   *
-   * @param {StreamRequest[]} newRequests - Array with new requests.
-   * @returns {boolean} - True if they are equal, false otherwise.
-   */
-  private checkIsNewRequestsEqualToPrev(newRequests: StreamRequest[]) {
-    return (
-      !isEmpty(this.previousStreamRequests) &&
-      this.previousStreamRequests.length === newRequests.length &&
-      this.previousStreamRequests.every((req, idx) => this.isEqual(req, newRequests[idx]))
-    );
-  }
-
   /**
    * Returns the maxPayloadBitsPerSecond per Stream
    *
@@ -230,15 +198,6 @@ export class MediaRequestManager {
     return (mediaRequest.codecInfo.maxFs * maxFps) / 100;
   }
 
-  /**
-   * Clears the previous stream requests.
-   *
-   * @returns {void}
-   */
-  public clearPreviousRequests(): void {
-    this.previousStreamRequests = [];
-  }
-
   /** Modifies the passed in clientRequests and makes sure that in total they don't ask
    *  for more streams than there are available.
    *
@@ -356,7 +315,7 @@ export class MediaRequestManager {
             mr.receiveSlots.map((receiveSlot) => receiveSlot.wcmeReceiveSlot),
             this.getMaxPayloadBitsPerSecond(mr),
             mr.codecInfo && [
-              new WcmeCodecInfo(
+              WcmeCodecInfo.fromH264(
                 0x80,
                 new H264Codec(
                   mr.codecInfo.maxFs,
@@ -372,17 +331,8 @@ export class MediaRequestManager {
       }
     });
 
-    //! IMPORTANT: this is only a temporary fix. This will soon be done in the jmp layer (@webex/json-multistream)
-    // https://jira-eng-gpk2.cisco.com/jira/browse/WEBEX-326713
-    if (!this.checkIsNewRequestsEqualToPrev(streamRequests)) {
-      this.sendMediaRequestsCallback(streamRequests);
-      this.previousStreamRequests = streamRequests;
-      LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent. `);
-    } else {
-      LoggerProxy.logger.info(
-        `multistream:sendRequests --> detected duplicate WCME requests, skipping them... `
-      );
-    }
+    this.sendMediaRequestsCallback(streamRequests);
+    LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent. `);
   }
 
   public addRequest(mediaRequest: MediaRequest, commit = true): MediaRequestId {

package/src/multistream/remoteMediaManager.ts

@@ -67,6 +67,18 @@ const AllEqualLayout: VideoLayout = {
   ],
 };
 
+// An "all equal" grid, with size up to 5 x 5 = 25:
+const AllEqual25Layout: VideoLayout = {
+  activeSpeakerVideoPaneGroups: [
+    {
+      id: 'main',
+      numPanes: 25,
+      size: 'best',
+      priority: 255,
+    },
+  ],
+};
+
 // A layout with just a single remote active speaker video pane:
 const SingleLayout: VideoLayout = {
   activeSpeakerVideoPaneGroups: [
@@ -164,6 +176,7 @@ export const DefaultConfiguration: Configuration = {
 
     layouts: {
       AllEqual: AllEqualLayout,
+      AllEqual25: AllEqual25Layout,
       OnePlusFive: OnePlusFiveLayout,
       Single: SingleLayout,
       Stage: Stage2x2With6ThumbnailsLayout,

package/src/multistream/sendSlotManager.ts

@@ -5,7 +5,11 @@ import {
   MultistreamRoapMediaConnection,
   NamedMediaGroup,
   StreamState,
+  MediaCodecMimeType,
+  CodecParameters,
 } from '@webex/internal-media-core';
+import Metrics from '../metrics';
+import BEHAVIORAL_METRICS from '../metrics/constants';
 
 /**
  * This class is used to manage the sendSlots for the given media types.
@@ -206,6 +210,8 @@ export default class SendSlotManager {
   }
 
   /**
+   * @deprecated Use {@link setCustomCodecParameters} instead, which requires specifying the codec MIME type.
+   *
    * This method is used to set the codec parameters for the sendSlot of the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be set (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
    * @param {Object} codecParameters
@@ -226,12 +232,19 @@ export default class SendSlotManager {
 
     await slot.setCodecParameters(codecParameters);
 
-    this.LoggerProxy.logger.info(
-      `SendSlotsManager->setCodecParameters#Set codec parameters for ${mediaType} to ${codecParameters}`
+    this.LoggerProxy.logger.warn(
+      'SendSlotsManager->setCodecParameters --> [DEPRECATION WARNING]: setCodecParameters has been deprecated, use setCustomCodecParameters instead'
     );
+
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DEPRECATED_SET_CODEC_PARAMETERS_USED, {
+      mediaType,
+      codecParameters,
+    });
   }
 
   /**
+   * @deprecated Use {@link markCustomCodecParametersForDeletion} instead, which requires specifying the codec MIME type.
+   *
    * This method is used to delete the codec parameters for the sendSlot of the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be deleted (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
    * @param {Array<String>} parameters Array of keys of the codec parameters to be deleted
@@ -246,8 +259,89 @@ export default class SendSlotManager {
 
     await slot.deleteCodecParameters(parameters);
 
+    this.LoggerProxy.logger.warn(
+      'SendSlotsManager->deleteCodecParameters --> [DEPRECATION WARNING]: deleteCodecParameters has been deprecated, use markCustomCodecParametersForDeletion instead'
+    );
+
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DEPRECATED_DELETE_CODEC_PARAMETERS_USED, {
+      mediaType,
+      parameters,
+    });
+  }
+
+  /**
+   * Sets custom codec parameters for the sendSlot of the given mediaType, scoped to a specific codec MIME type.
+   * Delegates to WCME's setCustomCodecParameters API.
+   * @param {MediaType} mediaType MediaType of the sendSlot
+   * @param {MediaCodecMimeType} codecMimeType The codec MIME type to apply parameters to (e.g. OPUS, H264, AV1)
+   * @param {CodecParameters} parameters Key-value pairs of codec parameters to set
+   * @returns {Promise<void>}
+   */
+  public async setCustomCodecParameters(
+    mediaType: MediaType,
+    codecMimeType: MediaCodecMimeType,
+    parameters: CodecParameters
+  ): Promise<void> {
+    const slot = this.slots.get(mediaType);
+
+    if (!slot) {
+      throw new Error(`Slot for ${mediaType} does not exist`);
+    }
+
+    try {
+      await slot.setCustomCodecParameters(codecMimeType, parameters);
+
+      this.LoggerProxy.logger.info(
+        `SendSlotsManager->setCustomCodecParameters#Set custom codec parameters for ${mediaType} (codec: ${codecMimeType}) to ${JSON.stringify(
+          parameters
+        )}`
+      );
+    } catch (error) {
+      this.LoggerProxy.logger.error(
+        `SendSlotsManager->setCustomCodecParameters#Failed to set custom codec parameters for ${mediaType} (codec: ${codecMimeType}): ${error}`
+      );
+      throw error;
+    } finally {
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.SET_CUSTOM_CODEC_PARAMETERS_USED, {
+        mediaType,
+        codecMimeType,
+        parameters,
+      });
+    }
+  }
+
+  /**
+   * Marks custom codec parameters for deletion on the sendSlot of the given mediaType, scoped to a specific codec MIME type.
+   * Delegates to WCME's markCustomCodecParametersForDeletion API.
+   * @param {MediaType} mediaType MediaType of the sendSlot
+   * @param {MediaCodecMimeType} codecMimeType The codec MIME type whose parameters should be deleted (e.g. OPUS, H264, AV1)
+   * @param {string[]} parameters Array of parameter keys to delete
+   * @returns {Promise<void>}
+   */
+  public async markCustomCodecParametersForDeletion(
+    mediaType: MediaType,
+    codecMimeType: MediaCodecMimeType,
+    parameters: string[]
+  ): Promise<void> {
+    const slot = this.slots.get(mediaType);
+
+    if (!slot) {
+      throw new Error(`Slot for ${mediaType} does not exist`);
+    }
+
+    await slot.markCustomCodecParametersForDeletion(codecMimeType, parameters);
+
     this.LoggerProxy.logger.info(
-      `SendSlotsManager->deleteCodecParameters#Deleted the following codec parameters -> ${parameters} for ${mediaType}`
+      `SendSlotsManager->markCustomCodecParametersForDeletion#Marked codec parameters for deletion -> ${parameters} for ${mediaType} (codec: ${codecMimeType})`
+    );
+
+    Metrics.sendBehavioralMetric(
+      BEHAVIORAL_METRICS.MARK_CUSTOM_CODEC_PARAMETERS_FOR_DELETION_USED,
+      {
+        mediaType,
+        codecMimeType,
+        parameters,
+      }
     );
   }
 

package/src/reachability/index.ts

@@ -6,6 +6,7 @@
 import {isEqual, mapValues, mean} from 'lodash';
 
 import {Defer} from '@webex/common';
+import {CapabilityState, WebCapabilities} from '@webex/web-capabilities';
 import LoggerProxy from '../common/logs/logger-proxy';
 import MeetingUtil from '../meeting/util';
 
@@ -196,6 +197,14 @@ export default class Reachability extends EventsScope {
     if (!this.webex.config.meetings.enableReachabilityChecks) {
       throw new Error('enableReachabilityChecks is disabled in config');
     }
+
+    if (WebCapabilities.supportsRTCPeerConnection() !== CapabilityState.CAPABLE) {
+      LoggerProxy.logger.warn(
+        'Reachability:index#gatherReachability --> WebRTC API is not available, skipping reachability checks'
+      );
+
+      return {};
+    }
     // Fetch clusters and measure latency
     try {
       this.lastTrigger = trigger;

package/src/reactions/reactions.type.ts

@@ -40,6 +40,7 @@ export enum SkinToneType {
 }
 
 export type Sender = {
+  displayName: string;
   participantId: string;
 };
 

package/src/reconnection-manager/index.ts

@@ -609,7 +609,6 @@ export default class ReconnectionManager {
     if (this.meeting.isMultistream) {
       Object.values(this.meeting.mediaRequestManagers).forEach(
         (mediaRequestManager: MediaRequestManager) => {
-          mediaRequestManager.clearPreviousRequests();
           mediaRequestManager.commit();
         }
       );

package/src/webinar/index.ts

@@ -4,10 +4,21 @@
 import {WebexPlugin, config} from '@webex/webex-core';
 import uuid from 'uuid';
 import {get} from 'lodash';
-import {_ID_, HEADERS, HTTP_VERBS, MEETINGS, SELF_ROLES, SHARE_STATUS} from '../constants';
+import {DataChannelTokenType} from '@webex/internal-plugin-llm';
+import {
+  _ID_,
+  HEADERS,
+  HTTP_VERBS,
+  MEETINGS,
+  SELF_ROLES,
+  SHARE_STATUS,
+  DEFAULT_LARGE_SCALE_WEBINAR_ATTENDEE_SEARCH_LIMIT,
+  LLM_PRACTICE_SESSION,
+} from '../constants';
 
 import WebinarCollection from './collection';
 import LoggerProxy from '../common/logs/logger-proxy';
+import {sanitizeParams} from './utils';
 
 /**
  * @class Webinar
@@ -28,6 +39,14 @@ const Webinar = WebexPlugin.extend({
     meetingId: 'string',
   },
 
+  /**
+   * Calls this to clean up listeners
+   * @returns {void}
+   */
+  cleanUp() {
+    this.cleanupPSDataChannel();
+  },
+
   /**
    * Update the current locus url of the webinar
    * @param {string} locusUrl
@@ -96,10 +115,7 @@ const Webinar = WebexPlugin.extend({
       meeting?.locusInfo?.updateMediaShares(meeting?.locusInfo?.mediaShares, true);
     }
 
-    if (this.practiceSessionEnabled) {
-      // may need change data channel in practice session
-      meeting?.updateLLMConnection();
-    }
+    this.updatePSDataChannel();
   },
 
   /**
@@ -110,6 +126,215 @@ const Webinar = WebexPlugin.extend({
     return this.selfIsPanelist && this.practiceSessionEnabled;
   },
 
+  /**
+   * Disconnects the practice session data channel and removes its relay listener.
+   * @returns {Promise<void>}
+   */
+  async cleanupPSDataChannel() {
+    if (this._pendingOnlineListener) {
+      // @ts-ignore - Fix type
+      this.webex.internal.llm.off('online', this._pendingOnlineListener);
+      this._pendingOnlineListener = null;
+    }
+
+    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+
+    // @ts-ignore - Fix type
+    await this.webex.internal.llm.disconnectLLM(
+      {
+        code: 3050,
+        reason: 'done (permanent)',
+      },
+      LLM_PRACTICE_SESSION
+    );
+    // @ts-ignore - Fix type
+    this.webex.internal.llm.off(
+      `event:relay.event:${LLM_PRACTICE_SESSION}`,
+      meeting?.processRelayEvent
+    );
+  },
+
+  /**
+   * Ensures practice-session token exists before registering the practice LLM channel.
+   * @param {object} meeting
+   * @returns {Promise<string|undefined>}
+   */
+  async ensurePracticeSessionDatachannelToken(meeting) {
+    // @ts-ignore
+    const isDataChannelTokenEnabled = await this.webex.internal.llm.isDataChannelTokenEnabled();
+
+    if (!isDataChannelTokenEnabled) {
+      return undefined;
+    }
+
+    // @ts-ignore
+    const cachedToken = this.webex.internal.llm.getDatachannelToken(
+      DataChannelTokenType.PracticeSession
+    );
+
+    if (cachedToken) {
+      return cachedToken;
+    }
+
+    try {
+      const refreshResponse = await meeting.refreshDataChannelToken();
+      const {datachannelToken, dataChannelTokenType} = refreshResponse?.body ?? {};
+
+      if (!datachannelToken) {
+        return undefined;
+      }
+
+      // @ts-ignore
+      this.webex.internal.llm.setDatachannelToken(
+        datachannelToken,
+        dataChannelTokenType || DataChannelTokenType.PracticeSession
+      );
+
+      return datachannelToken;
+    } catch (error) {
+      LoggerProxy.logger.warn(
+        `Webinar:index#ensurePracticeSessionDatachannelToken --> failed to proactively refresh practice-session token: ${
+          error?.message || String(error)
+        }`
+      );
+
+      return undefined;
+    }
+  },
+
+  /**
+   * Connects to low latency mercury and reconnects if the address has changed
+   * It will also disconnect if called when the meeting has ended
+   * @returns {Promise}
+   */
+  async updatePSDataChannel() {
+    this._updatePSDataChannelSequence = (this._updatePSDataChannelSequence || 0) + 1;
+    const invocationSequence = this._updatePSDataChannelSequence;
+
+    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+    const isPracticeSession = meeting?.isJoined() && this.isJoinPracticeSessionDataChannel();
+
+    if (!isPracticeSession) {
+      await this.cleanupPSDataChannel();
+
+      return undefined;
+    }
+
+    // @ts-ignore - Fix type
+    const {url = undefined, info: {practiceSessionDatachannelUrl = undefined} = {}} =
+      meeting?.locusInfo || {};
+
+    // @ts-ignore
+    let practiceSessionDatachannelToken = this.webex.internal.llm.getDatachannelToken(
+      DataChannelTokenType.PracticeSession
+    );
+
+    const isCaptionBoxOn = this.webex.internal.voicea.getIsCaptionBoxOn();
+
+    if (!practiceSessionDatachannelUrl) {
+      return undefined;
+    }
+    // @ts-ignore - Fix type
+    if (this.webex.internal.llm.isConnected(LLM_PRACTICE_SESSION)) {
+      if (
+        // @ts-ignore - Fix type
+        url === this.webex.internal.llm.getLocusUrl(LLM_PRACTICE_SESSION) &&
+        // @ts-ignore - Fix type
+        practiceSessionDatachannelUrl ===
+          this.webex.internal.llm.getDatachannelUrl(LLM_PRACTICE_SESSION)
+      ) {
+        return undefined;
+      }
+
+      await this.cleanupPSDataChannel();
+    }
+
+    // Ensure the default session data channel is connected before connecting the practice session.
+    // Subscribe before checking isConnected() to avoid a race where the 'online' event fires
+    // between the check and the subscription — Mercury does not replay missed events.
+    if (!this._pendingOnlineListener) {
+      const onDefaultSessionConnected = () => {
+        this._pendingOnlineListener = null;
+        // @ts-ignore - Fix type
+        this.webex.internal.llm.off('online', onDefaultSessionConnected);
+        this.updatePSDataChannel();
+      };
+      this._pendingOnlineListener = onDefaultSessionConnected;
+      // @ts-ignore - Fix type
+      this.webex.internal.llm.on('online', onDefaultSessionConnected);
+    }
+
+    // @ts-ignore - Fix type
+    if (!this.webex.internal.llm.isConnected()) {
+      LoggerProxy.logger.info(
+        'Webinar:index#updatePSDataChannel --> default session not yet connected, deferring practice session connect.'
+      );
+
+      return undefined;
+    }
+
+    // Default session is already connected — cancel the pending listener and proceed
+    if (this._pendingOnlineListener) {
+      // @ts-ignore - Fix type
+      this.webex.internal.llm.off('online', this._pendingOnlineListener);
+      this._pendingOnlineListener = null;
+    }
+
+    const refreshedPracticeSessionToken = await this.ensurePracticeSessionDatachannelToken(meeting);
+
+    const latestPracticeSessionDatachannelUrl = get(
+      meeting,
+      'locusInfo.info.practiceSessionDatachannelUrl'
+    );
+    const isStillPracticeSession = meeting?.isJoined() && this.isJoinPracticeSessionDataChannel();
+
+    // Skip stale invocations after async refresh to avoid reconnecting a session
+    // that was already updated/cleaned by a newer state transition.
+    if (
+      invocationSequence !== this._updatePSDataChannelSequence ||
+      !isStillPracticeSession ||
+      !latestPracticeSessionDatachannelUrl ||
+      latestPracticeSessionDatachannelUrl !== practiceSessionDatachannelUrl
+    ) {
+      return undefined;
+    }
+
+    if (refreshedPracticeSessionToken) {
+      practiceSessionDatachannelToken = refreshedPracticeSessionToken;
+    }
+
+    // @ts-ignore - Fix type
+    return this.webex.internal.llm
+      .registerAndConnect(
+        url,
+        practiceSessionDatachannelUrl,
+        practiceSessionDatachannelToken,
+        LLM_PRACTICE_SESSION
+      )
+      .then((registerAndConnectResult) => {
+        // @ts-ignore - Fix type
+        this.webex.internal.llm.off(
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          meeting?.processRelayEvent
+        );
+        // @ts-ignore - Fix type
+        this.webex.internal.llm.on(
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          meeting?.processRelayEvent
+        );
+        // @ts-ignore - Fix type
+        this.webex.internal.voicea?.announce?.();
+        if (isCaptionBoxOn) {
+          this.webex.internal.voicea.updateSubchannelSubscriptions({subscribe: ['transcription']});
+        }
+        LoggerProxy.logger.info(
+          `Webinar:index#updatePSDataChannel --> enabled to receive relay events for default session for ${LLM_PRACTICE_SESSION}!`
+        );
+
+        return Promise.resolve(registerAndConnectResult);
+      });
+  },
+
   /**
    * start or stop practice session for webinar
    * @param {boolean} enabled
@@ -137,6 +362,7 @@ const Webinar = WebexPlugin.extend({
    */
   updatePracticeSessionStatus(payload) {
     this.set('practiceSessionEnabled', !!payload?.enabled);
+    this.updatePSDataChannel().then(() => {});
   },
 
   /**
@@ -243,7 +469,6 @@ const Webinar = WebexPlugin.extend({
 
   /**
    * view all webcast attendees
-   * @param {string} queryString
    * @returns {Promise}
    */
   async viewAllWebcastAttendees() {
@@ -297,6 +522,40 @@ const Webinar = WebexPlugin.extend({
       throw error;
     });
   },
+
+  /**
+   * search large scale webinar attendees
+   * @param {object} payload
+   * @param {string} payload.queryString
+   * @param {number} payload.limit
+   * @param {string} payload.next
+   * @returns {Promise}
+   */
+  async searchLargeScaleWebinarAttendees(payload) {
+    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+    const rawParams = {
+      search_text: payload?.queryString,
+      limit: payload?.limit ?? DEFAULT_LARGE_SCALE_WEBINAR_ATTENDEE_SEARCH_LIMIT,
+      next: payload?.next,
+    };
+    const attendeeSearchUrl = meeting?.locusInfo?.links?.resources?.attendeeSearch?.url;
+    if (!attendeeSearchUrl) {
+      LoggerProxy.logger.error(`Meeting:webinar5k#searchLargeScaleWebinarAttendees failed`);
+      throw new Error('Meeting:webinar5k#Attendee search url is not available');
+    }
+
+    return this.request({
+      method: HTTP_VERBS.GET,
+      uri: `${attendeeSearchUrl}?${new URLSearchParams(sanitizeParams(rawParams)).toString()}`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar5k#searchLargeScaleWebinarAttendees failed', error);
+      throw error;
+    });
+  },
 });
 
 export default Webinar;

package/src/webinar/utils.ts

@@ -0,0 +1,16 @@
+/**
+ * Remove null/undefined/empty string values from an object
+ * @param {object} params
+ * @returns {object}
+ */
+export const sanitizeParams = (params: Record<string, any>) => {
+  const result: Record<string, any> = {};
+  Object.keys(params).forEach((key) => {
+    const value = params[key];
+    if (value !== null && value !== undefined && value !== '') {
+      result[key] = value;
+    }
+  });
+
+  return result;
+};