@webex/plugin-meetings 3.11.0 → 3.12.0

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,112 @@ 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() {
+    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} = {},
+      self: {practiceSessionDatachannelToken = undefined} = {},
+    } = meeting?.locusInfo || {};
+
+    // @ts-ignore
+    const currentToken = this.webex.internal.llm.getDatachannelToken(
+      DataChannelTokenType.PracticeSession
+    );
+
+    const finalToken = currentToken ?? practiceSessionDatachannelToken;
+
+    const isCaptionBoxOn = this.webex.internal.voicea.getIsCaptionBoxOn();
+
+    if (!currentToken && practiceSessionDatachannelToken) {
+      // @ts-ignore
+      this.webex.internal.llm.setDatachannelToken(
+        practiceSessionDatachannelToken,
+        DataChannelTokenType.PracticeSession
+      );
+    }
+
+    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();
+    }
+
+    // @ts-ignore - Fix type
+    return this.webex.internal.llm
+      .registerAndConnect(url, practiceSessionDatachannelUrl, finalToken, 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 +259,7 @@ const Webinar = WebexPlugin.extend({
    */
   updatePracticeSessionStatus(payload) {
     this.set('practiceSessionEnabled', !!payload?.enabled);
+    this.updatePSDataChannel().then(() => {});
   },
 
   /**
@@ -297,6 +420,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;
+};