@webex/plugin-meetings 3.11.0 → 3.12.0-next.2

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/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,141 @@ 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
+    );
+  },
+
+  /**
+   * 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() {
+    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
+    const 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;
+    }
+
+    // @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 +288,7 @@ const Webinar = WebexPlugin.extend({
    */
   updatePracticeSessionStatus(payload) {
     this.set('practiceSessionEnabled', !!payload?.enabled);
+    this.updatePSDataChannel().then(() => {});
   },
 
   /**
@@ -243,7 +395,6 @@ const Webinar = WebexPlugin.extend({
 
   /**
    * view all webcast attendees
-   * @param {string} queryString
    * @returns {Promise}
    */
   async viewAllWebcastAttendees() {
@@ -297,6 +448,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;
+};