@webex/plugin-meetings 3.10.0-next.9 → 3.10.0-set-bitrate.2

package/dist/types/locus-info/types.d.ts

@@ -0,0 +1,54 @@
+import { HtMeta } from '../hashTree/types';
+export type LocusFullState = {
+    active: boolean;
+    count: number;
+    lastActive: string;
+    locked: boolean;
+    sessionId: string;
+    seessionIds: string[];
+    startTime: number;
+    state: string;
+    type: string;
+};
+export type Links = {
+    services: Record<'breakout' | 'record', {
+        url: string;
+    }>;
+    resources: Record<'webcastInstance' | 'visibleDataSets', {
+        url: string;
+    }>;
+};
+export type LocusDTO = {
+    controls?: any;
+    fullState?: LocusFullState;
+    host?: {
+        id: string;
+        incomingCallProtocols: any[];
+        isExternal: boolean;
+        name: string;
+        orgId: string;
+    };
+    htMeta?: HtMeta;
+    info?: any;
+    jsSdkMeta?: {
+        removedParticipantIds: string[];
+    };
+    links?: Links;
+    mediaShares?: any[];
+    meetings?: any[];
+    participants: any[];
+    replaces?: any[];
+    self?: any;
+    sequence?: {
+        dirtyParticipants: number;
+        entries: number[];
+        rangeEnd: number;
+        rangeStart: number;
+        sequenceHash: number;
+        sessionToken: string;
+        since: string;
+        totalParticipants: number;
+    };
+    syncUrl?: string;
+    url?: string;
+};

package/dist/types/meeting/index.d.ts

@@ -23,6 +23,8 @@ import { LocusMediaRequest } from './locusMediaRequest';
 import { BrbState } from './brbState';
 import { SetStageOptions } from './request.type';
 import { Invitee } from './type';
+import { DataSet } from '../hashTree/hashTreeParser';
+import { LocusDTO } from '../locus-info/types';
 export type CaptionData = {
     id: string;
     isFinal: boolean;
@@ -456,6 +458,7 @@ export default class Meeting extends StatelessWebexPlugin {
     localAudioStreamMuteStateHandler: () => void;
     localVideoStreamMuteStateHandler: () => void;
     localOutputTrackChangeHandler: () => void;
+    localConstraintsChangeHandler: () => void;
     roles: any[];
     environment: string;
     namespace: string;
@@ -1034,25 +1037,30 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     setSipUri(sipUri: string): void;
     /**
-     * Set the locus info the class instance
-     * @param {Object} locus
-     * @param {Array} locus.mediaConnections
-     * @param {String} locus.locusUrl
-     * @param {String} locus.locusId
-     * @param {String} locus.mediaId
-     * @param {Object} locus.host
+     * Set the locus info the class instance. Should be called with the parsed locus
+     * we got in the join response.
+     *
+     * @param {Object} data
+     * @param {Array} data.mediaConnections
+     * @param {String} data.locusUrl
+     * @param {String} data.locusId
+     * @param {String} data.mediaId
+     * @param {Object} data.host
      * @todo change name to genertic parser
      * @returns {undefined}
      * @private
      * @memberof Meeting
      */
-    setLocus(locus: {
+    setLocus(data: {
+        locus: LocusDTO;
         mediaConnections: Array<any>;
         locusUrl: string;
         locusId: string;
         mediaId: string;
         host: object;
-    } | any): void;
+        selfId: string;
+        dataSets: DataSet[];
+    }): void;
     /**
      * Upload logs for the current meeting
      * @param {object} options file name and function name
@@ -1269,6 +1277,12 @@ export default class Meeting extends StatelessWebexPlugin {
     startTranscription(options?: {
         spokenLanguage?: string;
     }): Promise<void>;
+    /** Handles Locus LLM events
+     *
+     * @param {LocusLLMEvent} event - The Locus LLM event to process
+     * @returns {void}
+     */
+    private processLocusLLMEvent;
     /**
      * Callback called when a relay event is received from meeting LLM Connection
      * @param {RelayEvent} e Event object coming from LLM Connection

package/dist/types/meetings/index.d.ts

@@ -5,10 +5,17 @@ import { WebexPlugin } from '@webex/webex-core';
 import { DeviceRegistrationOptions } from '@webex/internal-plugin-device';
 import * as mediaHelpersModule from '@webex/media-helpers';
 import 'webrtc-adapter';
-import { DESTINATION_TYPE } from '../constants';
+import { LOCUSEVENT, DESTINATION_TYPE } from '../constants';
 import { CallStateForMetrics } from '../meeting';
 import Reachability from '../reachability';
 import { INoiseReductionEffect, IVirtualBackgroundEffect, MeetingRegistrationStatus } from './meetings.types';
+import { HashTreeMessage } from '../hashTree/hashTreeParser';
+export type LocusEvent = {
+    eventType: LOCUSEVENT;
+    locusUrl?: string;
+    locus?: any;
+    stateElementsMessage?: HashTreeMessage;
+};
 /**
  * Meetings Ready Event
  * Emitted when the meetings instance on webex is ready
@@ -129,7 +136,7 @@ export default class Meetings extends WebexPlugin {
      * @private
      * @memberof Meetings
      */
-    getCorrespondingMeetingByLocus(data: any): any;
+    getCorrespondingMeetingByLocus(data: LocusEvent): any;
     /**
      * handle locus events and takes meeting actions with them as they come in
      * @param {Object} data a locus event

package/dist/types/metrics/constants.d.ts

@@ -84,5 +84,7 @@ declare const BEHAVIORAL_METRICS: {
     VERIFY_REGISTRATION_ID_ERROR: string;
     JOIN_FORBIDDEN_ERROR: string;
     MEDIA_ISSUE_DETECTED: string;
+    LOCUS_CLASSIC_VS_HASH_TREE_MISMATCH: string;
+    LOCUS_HASH_TREE_UNSUPPORTED_OPERATION: string;
 };
 export { BEHAVIORAL_METRICS as default };

package/dist/types/reachability/clusterReachability.d.ts

@@ -23,17 +23,11 @@ export declare const Events: {
 export type Events = Enum<typeof Events>;
 /**
  * A class that handles reachability checks for a single cluster.
- * It emits events from Events enum
+ * Creates and orchestrates a ReachabilityPeerConnection instance.
+ * Listens to events and emits them to consumers.
  */
 export declare class ClusterReachability extends EventsScope {
-    private numUdpUrls;
-    private numTcpUrls;
-    private numXTlsUrls;
-    private result;
-    private pc?;
-    private defer;
-    private startTimestamp;
-    private srflxIceCandidates;
+    private reachabilityPeerConnection;
     readonly isVideoMesh: boolean;
     readonly name: any;
     readonly reachedSubnets: Set<string>;
@@ -44,94 +38,22 @@ export declare class ClusterReachability extends EventsScope {
      */
     constructor(name: string, clusterInfo: ClusterNode);
     /**
-     * Gets total elapsed time, can be called only after start() is called
-     * @returns {Number} Milliseconds
-     */
-    private getElapsedTime;
-    /**
-     * Generate peerConnection config settings
-     * @param {ClusterNode} cluster
-     * @returns {RTCConfiguration} peerConnectionConfig
-     */
-    private buildPeerConnectionConfig;
-    /**
-     * Creates an RTCPeerConnection
-     * @param {ClusterNode} clusterInfo information about the media cluster
-     * @returns {RTCPeerConnection} peerConnection
+     * Sets up event listeners for the ReachabilityPeerConnection instance
+     * @returns {void}
      */
-    private createPeerConnection;
+    private setupReachabilityPeerConnectionEventListeners;
     /**
      * @returns {ClusterReachabilityResult} reachability result for this cluster
      */
     getResult(): ClusterReachabilityResult;
     /**
-     * Closes the peerConnection
-     *
-     * @returns {void}
-     */
-    private closePeerConnection;
-    /**
-     * Resolves the defer, indicating that reachability checks for this cluster are completed
-     *
-     * @returns {void}
+     * Starts the process of doing UDP, TCP, and XTLS reachability checks on the media cluster.
+     * @returns {Promise<ClusterReachabilityResult>}
      */
-    private finishReachabilityCheck;
+    start(): Promise<ClusterReachabilityResult>;
     /**
-     * Aborts the cluster reachability checks by closing the peer connection
-     *
+     * Aborts the cluster reachability checks
      * @returns {void}
      */
     abort(): void;
-    /**
-     * Adds public IP (client media IPs)
-     * @param {string} protocol
-     * @param {string} publicIP
-     * @returns {void}
-     */
-    private addPublicIP;
-    /**
-     * Registers a listener for the iceGatheringStateChange event
-     *
-     * @returns {void}
-     */
-    private registerIceGatheringStateChangeListener;
-    /**
-     * Saves the latency in the result for the given protocol and marks it as reachable,
-     * emits the "resultReady" event if this is the first result for that protocol,
-     * emits the "clientMediaIpsUpdated" event if we already had a result and only found
-     * a new client IP
-     *
-     * @param {string} protocol
-     * @param {number} latency
-     * @param {string|null} [publicIp]
-     * @param {string|null} [serverIp]
-     * @returns {void}
-     */
-    private saveResult;
-    /**
-     * Determines NAT Type.
-     *
-     * @param {RTCIceCandidate} candidate
-     * @returns {void}
-     */
-    private determineNatType;
-    /**
-     * Registers a listener for the icecandidate event
-     *
-     * @returns {void}
-     */
-    private registerIceCandidateListener;
-    /**
-     * Starts the process of doing UDP and TCP reachability checks on the media cluster.
-     * XTLS reachability checking is not supported.
-     *
-     * @returns {Promise}
-     */
-    start(): Promise<ClusterReachabilityResult>;
-    /**
-     * Starts the process of gathering ICE candidates
-     *
-     * @returns {Promise} promise that's resolved once reachability checks for this cluster are completed or timeout is reached
-     */
-    private gatherIceCandidates;
 }

package/dist/types/reachability/reachability.types.d.ts

@@ -1,4 +1,15 @@
-import { IP_VERSION } from '../constants';
+import { IP_VERSION, Enum } from '../constants';
+export type Protocol = 'udp' | 'tcp' | 'xtls';
+/**
+ * Events emitted by ReachabilityPeerConnection
+ */
+export declare const ReachabilityPeerConnectionEvents: {
+    readonly resultReady: "resultReady";
+    readonly clientMediaIpsUpdated: "clientMediaIpsUpdated";
+    readonly natTypeUpdated: "natTypeUpdated";
+    readonly reachedSubnets: "reachedSubnets";
+};
+export type ReachabilityPeerConnectionEvents = Enum<typeof ReachabilityPeerConnectionEvents>;
 export type TransportResult = {
     result: 'reachable' | 'unreachable' | 'untested';
     latencyInMilliseconds?: number;

package/dist/types/reachability/reachabilityPeerConnection.d.ts

@@ -0,0 +1,111 @@
+import { ClusterNode } from './request';
+import EventsScope from '../common/events/events-scope';
+import { ClusterReachabilityResult } from './reachability.types';
+/**
+ * A class to handle RTCPeerConnection lifecycle and ICE candidate gathering for reachability checks.
+ * It will do all the work like PeerConnection lifecycle, candidate processing, result management, and event emission.
+ */
+export declare class ReachabilityPeerConnection extends EventsScope {
+    numUdpUrls: number;
+    numTcpUrls: number;
+    numXTlsUrls: number;
+    private pc;
+    private defer;
+    private startTimestamp;
+    private srflxIceCandidates;
+    private clusterName;
+    private result;
+    private emittedSubnets;
+    /**
+     * Constructor for ReachabilityPeerConnection
+     * @param {string} clusterName name of the cluster
+     * @param {ClusterNode} clusterInfo information about the media cluster
+     */
+    constructor(clusterName: string, clusterInfo: ClusterNode);
+    /**
+     * Gets total elapsed time, can be called only after start() is called
+     * @returns {number} Milliseconds
+     */
+    private getElapsedTime;
+    /**
+     * Generate peerConnection config settings
+     * @param {ClusterNode} cluster
+     * @returns {RTCConfiguration} peerConnectionConfig
+     */
+    private static buildPeerConnectionConfig;
+    /**
+     * Creates an RTCPeerConnection
+     * @param {ClusterNode} clusterInfo information about the media cluster
+     * @returns {RTCPeerConnection|null} peerConnection
+     */
+    private createPeerConnection;
+    /**
+     * @returns {ClusterReachabilityResult} reachability result for this instance
+     */
+    getResult(): ClusterReachabilityResult;
+    /**
+     * Closes the peerConnection
+     * @returns {void}
+     */
+    private closePeerConnection;
+    /**
+     * Resolves the defer, indicating that reachability checks for this cluster are completed
+     *
+     * @returns {void}
+     */
+    private finishReachabilityCheck;
+    /**
+     * Aborts the cluster reachability checks by closing the peer connection
+     *
+     * @returns {void}
+     */
+    abort(): void;
+    /**
+     * Adds public IP (client media IPs)
+     * @param {string} protocol
+     * @param {string} publicIp
+     * @returns {void}
+     */
+    private addPublicIp;
+    /**
+     * Registers a listener for the iceGatheringStateChange event
+     *
+     * @returns {void}
+     */
+    private registerIceGatheringStateChangeListener;
+    /**
+     * Saves the latency in the result for the given protocol and marks it as reachable,
+     * emits the "resultReady" event if this is the first result for that protocol,
+     * emits the "clientMediaIpsUpdated" event if we already had a result and only found
+     * a new client IP
+     *
+     * @param {string} protocol
+     * @param {number} latency
+     * @param {string|null} [publicIp]
+     * @param {string|null} [serverIp]
+     * @returns {void}
+     */
+    private saveResult;
+    /**
+     * Determines NAT type by analyzing server reflexive candidate patterns
+     * @param {RTCIceCandidate} candidate server reflexive candidate
+     * @returns {void}
+     */
+    private determineNatTypeForSrflxCandidate;
+    /**
+     * Registers a listener for the icecandidate event
+     *
+     * @returns {void}
+     */
+    private registerIceCandidateListener;
+    /**
+     * Starts the process of doing UDP, TCP, and XTLS reachability checks.
+     * @returns {Promise<ClusterReachabilityResult>}
+     */
+    start(): Promise<ClusterReachabilityResult>;
+    /**
+     * Starts the process of gathering ICE candidates
+     * @returns {Promise} promise that's resolved once reachability checks are completed or timeout is reached
+     */
+    private gatherIceCandidates;
+}

package/dist/webinar/index.js

@@ -448,7 +448,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
       }, _callee7);
     }))();
   },
-  version: "3.10.0-next.9"
+  version: "3.10.0-set-bitrate.2"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -43,12 +43,12 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/plugin-rooms": "3.10.0-next.4",
-    "@webex/test-helper-chai": "3.8.1-next.11",
-    "@webex/test-helper-mocha": "3.8.1-next.11",
-    "@webex/test-helper-mock-webex": "3.8.1-next.11",
-    "@webex/test-helper-retry": "3.8.1-next.11",
-    "@webex/test-helper-test-users": "3.8.1-next.11",
+    "@webex/plugin-rooms": "3.10.0-set-bitrate.1",
+    "@webex/test-helper-chai": "3.10.0-set-bitrate.1",
+    "@webex/test-helper-mocha": "3.10.0-set-bitrate.1",
+    "@webex/test-helper-mock-webex": "3.10.0-set-bitrate.1",
+    "@webex/test-helper-retry": "3.10.0-set-bitrate.1",
+    "@webex/test-helper-test-users": "3.10.0-set-bitrate.1",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "eslint": "^8.24.0",
@@ -60,23 +60,23 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.8.1-next.11",
+    "@webex/common": "3.10.0-set-bitrate.1",
     "@webex/event-dictionary-ts": "^1.0.1930",
-    "@webex/internal-media-core": "2.20.3",
-    "@webex/internal-plugin-conversation": "3.10.0-next.4",
-    "@webex/internal-plugin-device": "3.10.0-next.4",
-    "@webex/internal-plugin-llm": "3.10.0-next.4",
-    "@webex/internal-plugin-mercury": "3.10.0-next.4",
-    "@webex/internal-plugin-metrics": "3.10.0-next.4",
-    "@webex/internal-plugin-support": "3.10.0-next.4",
-    "@webex/internal-plugin-user": "3.10.0-next.4",
-    "@webex/internal-plugin-voicea": "3.10.0-next.5",
-    "@webex/media-helpers": "3.10.0-next.2",
-    "@webex/plugin-people": "3.10.0-next.4",
-    "@webex/plugin-rooms": "3.10.0-next.4",
+    "@webex/internal-media-core": "2.21.0",
+    "@webex/internal-plugin-conversation": "3.10.0-set-bitrate.1",
+    "@webex/internal-plugin-device": "3.10.0-set-bitrate.1",
+    "@webex/internal-plugin-llm": "3.10.0-set-bitrate.1",
+    "@webex/internal-plugin-mercury": "3.10.0-set-bitrate.1",
+    "@webex/internal-plugin-metrics": "3.10.0-set-bitrate.1",
+    "@webex/internal-plugin-support": "3.10.0-set-bitrate.1",
+    "@webex/internal-plugin-user": "3.10.0-set-bitrate.1",
+    "@webex/internal-plugin-voicea": "3.10.0-set-bitrate.1",
+    "@webex/media-helpers": "3.10.0-set-bitrate.2",
+    "@webex/plugin-people": "3.10.0-set-bitrate.1",
+    "@webex/plugin-rooms": "3.10.0-set-bitrate.1",
     "@webex/ts-sdp": "^1.8.1",
     "@webex/web-capabilities": "^1.7.1",
-    "@webex/webex-core": "3.10.0-next.4",
+    "@webex/webex-core": "3.10.0-set-bitrate.1",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
@@ -87,10 +87,11 @@
     "jwt-decode": "3.1.2",
     "lodash": "^4.17.21",
     "uuid": "^3.3.2",
-    "webrtc-adapter": "^8.1.2"
+    "webrtc-adapter": "^8.1.2",
+    "xxh3-ts": "^2.0.1"
   },
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.10.0-next.9"
+  "version": "3.10.0-set-bitrate.2"
 }

package/src/constants.ts

@@ -793,7 +793,19 @@ export const LOCUSEVENT = {
   RECORDING_STOPPED: 'locus.recording_stopped',
 
   SELF_CHANGED: 'locus.self_changed',
-};
+
+  HASH_TREE_DATA_UPDATED: 'locus.state_message',
+
+  // events generated internally by SDK
+  SDK_LOCUS_FROM_SYNC_MEETINGS: 'jsSdk.locus_from_sync_meetings', // generated for each meeting from response to GET /loci Locus API call
+  SDK_NO_EVENT: 'jsSdk.no_event', // used in cases where eventType is irrelevant
+} as const;
+
+export type LOCUSEVENT = Enum<typeof LOCUSEVENT>;
+
+// HASH_TREE_DATA_UPDATED event can come over Mercury (so it's listed above with other Mercury events),
+// but also over LLM as an event like this:
+export const LOCUS_LLM_EVENT = `event:${LOCUSEVENT.HASH_TREE_DATA_UPDATED}`;
 
 export const MEDIA_TRACK_CONSTRAINT = {
   CURSOR: {

package/src/hashTree/constants.ts

@@ -0,0 +1,9 @@
+export const EMPTY_HASH = '99aa06d3014798d86001c324468d497f';
+
+export const DataSetNames = {
+  MAIN: 'main', // sent to web client, contains also panelists, over LLM
+  ATTENDEES: 'attendees', // NOT SENT to web client, all the attendees in the locus
+  ATD_ACTIVE: 'atd-active', // only sent to panelists, over LLM; the attendees that have their hands raised or are allowed to unmute themselves
+  ATD_UNMUTED: 'atd-unmuted', // sent to web client, over LLM, not sent to panelists; the attendees that are unmuted
+  SELF: 'self', // sent to web client, over Mercury
+};