@webex/plugin-meetings 3.3.1 → 3.4.0-next.10

package/package.json

@@ -43,13 +43,13 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/plugin-meetings": "3.3.1",
-    "@webex/plugin-rooms": "3.3.1",
-    "@webex/test-helper-chai": "3.3.1",
-    "@webex/test-helper-mocha": "3.3.1",
-    "@webex/test-helper-mock-webex": "3.3.1",
-    "@webex/test-helper-retry": "3.3.1",
-    "@webex/test-helper-test-users": "3.3.1",
+    "@webex/plugin-meetings": "3.4.0-next.10",
+    "@webex/plugin-rooms": "3.4.0-next.2",
+    "@webex/test-helper-chai": "3.4.0-next.2",
+    "@webex/test-helper-mocha": "3.4.0-next.2",
+    "@webex/test-helper-mock-webex": "3.4.0-next.2",
+    "@webex/test-helper-retry": "3.4.0-next.2",
+    "@webex/test-helper-test-users": "3.4.0-next.2",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "eslint": "^8.24.0",
@@ -61,20 +61,21 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.3.1",
-    "@webex/internal-media-core": "2.5.1",
-    "@webex/internal-plugin-conversation": "3.3.1",
-    "@webex/internal-plugin-device": "3.3.1",
-    "@webex/internal-plugin-llm": "3.3.1",
-    "@webex/internal-plugin-mercury": "3.3.1",
-    "@webex/internal-plugin-metrics": "3.3.1",
-    "@webex/internal-plugin-support": "3.3.1",
-    "@webex/internal-plugin-user": "3.3.1",
-    "@webex/internal-plugin-voicea": "3.3.1",
-    "@webex/media-helpers": "3.3.1",
-    "@webex/plugin-people": "3.3.1",
-    "@webex/plugin-rooms": "3.3.1",
-    "@webex/webex-core": "3.3.1",
+    "@webex/common": "3.4.0-next.2",
+    "@webex/internal-media-core": "2.10.2",
+    "@webex/internal-plugin-conversation": "3.4.0-next.2",
+    "@webex/internal-plugin-device": "3.4.0-next.2",
+    "@webex/internal-plugin-llm": "3.4.0-next.2",
+    "@webex/internal-plugin-mercury": "3.4.0-next.2",
+    "@webex/internal-plugin-metrics": "3.4.0-next.2",
+    "@webex/internal-plugin-support": "3.4.0-next.2",
+    "@webex/internal-plugin-user": "3.4.0-next.2",
+    "@webex/internal-plugin-voicea": "3.4.0-next.10",
+    "@webex/media-helpers": "3.4.0-next.4",
+    "@webex/plugin-people": "3.4.0-next.2",
+    "@webex/plugin-rooms": "3.4.0-next.2",
+    "@webex/web-capabilities": "^1.4.0",
+    "@webex/webex-core": "3.4.0-next.2",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
@@ -84,12 +85,11 @@
     "javascript-state-machine": "^3.1.0",
     "jwt-decode": "3.1.2",
     "lodash": "^4.17.21",
-    "sdp-transform": "^2.12.0",
     "uuid": "^3.3.2",
     "webrtc-adapter": "^8.1.2"
   },
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.3.1"
+  "version": "3.4.0-next.10"
 }

package/src/breakouts/index.ts

@@ -148,7 +148,6 @@ const Breakouts = WebexPlugin.extend({
       this.triggerReturnToMainEvent(breakout);
     });
     this.listenToCurrentSessionTypeChange();
-    this.listenToBroadcastMessages();
     this.listenToBreakoutRosters();
     this.listenToBreakoutHelp();
     // @ts-ignore
@@ -161,6 +160,7 @@ const Breakouts = WebexPlugin.extend({
    */
   cleanUp() {
     this.stopListening();
+    this.hasSubscribedToMessage = undefined;
   },
 
   /**
@@ -170,6 +170,7 @@ const Breakouts = WebexPlugin.extend({
    */
   locusUrlUpdate(locusUrl) {
     this.set('locusUrl', locusUrl);
+    this.listenToBroadcastMessages();
     const {isInMainSession, mainLocusUrl} = this;
     if (isInMainSession || !mainLocusUrl) {
       this.set('mainLocusUrl', locusUrl);
@@ -255,6 +256,10 @@ const Breakouts = WebexPlugin.extend({
    * @returns {void}
    */
   listenToBroadcastMessages() {
+    if (!this.webex.internal.llm.isConnected() || this.hasSubscribedToMessage) {
+      return;
+    }
+
     this.listenTo(this.webex.internal.llm, 'event:breakout.message', (event) => {
       const {
         data: {senderUserId, sentTime, message},
@@ -270,6 +275,7 @@ const Breakouts = WebexPlugin.extend({
         sessionId: this.currentBreakoutSession.sessionId,
       });
     });
+    this.hasSubscribedToMessage = true;
   },
 
   /**

package/src/constants.ts

@@ -250,23 +250,6 @@ export const ASSIGN_ROLES_ERROR_CODES = {
   ReclaimHostIsHostAlreadyErrorCode: 2409150,
 };
 
-export const DEFAULT_GET_STATS_FILTER = {
-  types: [
-    'track',
-    'transport',
-    'candidate-pair',
-    'outbound-rtp',
-    'outboundrtp',
-    'inbound-rtp',
-    'inboundrtp',
-    'remote-inbound-rtp',
-    'remote-outbound-rtp',
-    'remote-candidate',
-    'local-candidate',
-    'media-source',
-  ],
-};
-
 export const RECORDING_STATE = {
   RECORDING: 'recording',
   IDLE: 'idle',
@@ -1331,3 +1314,16 @@ export const MEETING_PERMISSION_TOKEN_REFRESH_REASON = 'ttl-join';
 
 // constant for named media group type
 export const NAMED_MEDIA_GROUP_TYPE_AUDIO = 1;
+
+export const DESTINATION_TYPE = {
+  CONVERSATION_URL: 'CONVERSATION_URL',
+  MEETING_LINK: 'MEETING_LINK',
+  SIP_URI: 'SIP_URI',
+  PERSONAL_ROOM: 'PERSONAL_ROOM',
+  ONE_ON_ONE_CALL: 'ONE_ON_ONE_CALL',
+  LOCUS_ID: 'LOCUS_ID',
+  MEETING_ID: 'MEETING_ID',
+  MEETING_UUID: 'MEETING_UUID',
+} as const;
+
+export type DESTINATION_TYPE = Enum<typeof DESTINATION_TYPE>;

package/src/locus-info/selfUtils.ts

@@ -428,11 +428,6 @@ SelfUtils.mutedByOthersChanged = (oldSelf, changedSelf) => {
     return false;
   }
 
-  // there is no need to trigger user update if no one muted user
-  if (changedSelf.selfIdentity === changedSelf.modifiedBy) {
-    return false;
-  }
-
   return (
     changedSelf.remoteMuted !== null &&
     (oldSelf.remoteMuted !== changedSelf.remoteMuted ||

package/src/media/MediaConnectionAwaiter.ts

@@ -1,5 +1,5 @@
 import {Defer} from '@webex/common';
-import {ConnectionState, Event} from '@webex/internal-media-core';
+import {ConnectionState, MediaConnectionEventNames} from '@webex/internal-media-core';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {ICE_AND_DTLS_CONNECTION_TIMEOUT} from '../constants';
 
@@ -15,8 +15,10 @@ export default class MediaConnectionAwaiter {
   private timer: any;
   private defer: Defer;
   private retried: boolean;
+  private iceConnected: boolean;
   private onTimeoutCallback: () => void;
-  private connectionStateCallback: () => void;
+  private peerConnectionStateCallback: () => void;
+  private iceConnectionStateCallback: () => void;
   private iceGatheringStateCallback: () => void;
 
   /**
@@ -26,9 +28,11 @@ export default class MediaConnectionAwaiter {
     this.webrtcMediaConnection = webrtcMediaConnection;
     this.defer = new Defer();
     this.retried = false;
+    this.iceConnected = false;
     this.onTimeoutCallback = this.onTimeout.bind(this);
-    this.connectionStateCallback = this.connectionStateListenerCallback.bind(this);
-    this.iceGatheringStateCallback = this.iceGatheringStateListenerCallback.bind(this);
+    this.peerConnectionStateCallback = this.peerConnectionStateHandler.bind(this);
+    this.iceConnectionStateCallback = this.iceConnectionStateHandler.bind(this);
+    this.iceGatheringStateCallback = this.iceGatheringStateHandler.bind(this);
   }
 
   /**
@@ -40,6 +44,15 @@ export default class MediaConnectionAwaiter {
     return this.webrtcMediaConnection.getConnectionState() === ConnectionState.Connected;
   }
 
+  /**
+   * Returns true if the connection is in an unrecoverable "failed" state
+   *
+   * @returns {boolean}
+   */
+  private isFailed(): boolean {
+    return this.webrtcMediaConnection.getConnectionState() === ConnectionState.Failed;
+  }
+
   /**
    * Returns true if the ICE Gathering is completed, false otherwise.
    *
@@ -56,22 +69,40 @@ export default class MediaConnectionAwaiter {
    */
   private clearCallbacks(): void {
     this.webrtcMediaConnection.off(
-      Event.ICE_GATHERING_STATE_CHANGED,
+      MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED,
       this.iceGatheringStateCallback
     );
-    this.webrtcMediaConnection.off(Event.CONNECTION_STATE_CHANGED, this.connectionStateCallback);
+    this.webrtcMediaConnection.off(
+      MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED,
+      this.peerConnectionStateCallback
+    );
+    this.webrtcMediaConnection.off(
+      MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED,
+      this.iceConnectionStateCallback
+    );
   }
 
   /**
-   * Listener for connection state change.
+   * On connection state change.
    *
    * @returns {void}
    */
-  connectionStateListenerCallback(): void {
+  connectionStateChange(): void {
     LoggerProxy.logger.log(
-      `Media:MediaConnectionAwaiter#connectionStateListenerCallback --> connection state: ${this.webrtcMediaConnection.getConnectionState()}`
+      `Media:MediaConnectionAwaiter#connectionStateChange --> connection state: ${this.webrtcMediaConnection.getConnectionState()}`
     );
 
+    if (this.isFailed()) {
+      LoggerProxy.logger.warn(
+        'Media:MediaConnectionAwaiter#connectionStateChange --> ICE failed, rejecting'
+      );
+      this.clearCallbacks();
+
+      this.defer.reject({
+        iceConnected: this.iceConnected,
+      });
+    }
+
     if (!this.isConnected()) {
       return;
     }
@@ -83,16 +114,50 @@ export default class MediaConnectionAwaiter {
     this.defer.resolve();
   }
 
+  /**
+   * Listener for peer connection state change.
+   *
+   * @returns {void}
+   */
+  peerConnectionStateHandler(): void {
+    const peerConnectionState = this.webrtcMediaConnection.getPeerConnectionState();
+
+    LoggerProxy.logger.log(
+      `Media:MediaConnectionAwaiter#peerConnectionStateHandler --> Peer connection state change -> ${peerConnectionState}`
+    );
+
+    this.connectionStateChange();
+  }
+
+  /**
+   * Listener for ICE connection state change.
+   *
+   * @returns {void}
+   */
+  iceConnectionStateHandler(): void {
+    const iceConnectionState = this.webrtcMediaConnection.getIceConnectionState();
+
+    LoggerProxy.logger.log(
+      `Media:MediaConnectionAwaiter#iceConnectionStateHandler --> ICE connection state change -> ${iceConnectionState}`
+    );
+
+    if (iceConnectionState === 'connected' && !this.iceConnected) {
+      this.iceConnected = true;
+    }
+
+    this.connectionStateChange();
+  }
+
   /**
    * Listener for ICE gathering state change.
    *
    * @returns {void}
    */
-  iceGatheringStateListenerCallback(): void {
+  iceGatheringStateHandler(): void {
     const iceGatheringState = this.webrtcMediaConnection.getIceGatheringState();
 
     LoggerProxy.logger.log(
-      `Media:MediaConnectionAwaiter#iceGatheringStateListenerCallback --> ICE gathering state change -> ${iceGatheringState}`
+      `Media:MediaConnectionAwaiter#iceGatheringStateHandler --> ICE gathering state change -> ${iceGatheringState}`
     );
 
     if (!this.isIceGatheringCompleted()) {
@@ -147,7 +212,9 @@ export default class MediaConnectionAwaiter {
 
     this.clearCallbacks();
 
-    this.defer.reject();
+    this.defer.reject({
+      iceConnected: this.iceConnected,
+    });
   }
 
   /**
@@ -160,10 +227,18 @@ export default class MediaConnectionAwaiter {
       return Promise.resolve();
     }
 
-    this.webrtcMediaConnection.on(Event.CONNECTION_STATE_CHANGED, this.connectionStateCallback);
+    this.webrtcMediaConnection.on(
+      MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED,
+      this.peerConnectionStateCallback
+    );
+
+    this.webrtcMediaConnection.on(
+      MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED,
+      this.iceConnectionStateCallback
+    );
 
     this.webrtcMediaConnection.on(
-      Event.ICE_GATHERING_STATE_CHANGED,
+      MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED,
       this.iceGatheringStateCallback
     );
 

package/src/media/index.ts

@@ -104,9 +104,7 @@ Media.getDirection = (forceSendRecv: boolean, receive: boolean, send: boolean) =
  *
  * @param {boolean} isMultistream
  * @param {string} debugId string useful for debugging (will appear in media connection logs)
- * @param {object} webex main `webex` object.
  * @param {string} meetingId id for the meeting using this connection
- * @param {string} correlationId id used in requests to correlate to this session
  * @param {Object} options
  * @param {Object} [options.mediaProperties] contains mediaDirection and local tracks:
  *                                 audioTrack, videoTrack, shareVideoTrack, and shareAudioTrack
@@ -120,10 +118,9 @@ Media.getDirection = (forceSendRecv: boolean, receive: boolean, send: boolean) =
 Media.createMediaConnection = (
   isMultistream: boolean,
   debugId: string,
-  webex: object,
   meetingId: string,
-  correlationId: string,
   options: {
+    rtcMetrics?: RtcMetrics;
     mediaProperties: {
       mediaDirection?: {
         receiveAudio: boolean;
@@ -150,6 +147,7 @@ Media.createMediaConnection = (
   }
 ) => {
   const {
+    rtcMetrics,
     mediaProperties,
     remoteQualityLevel,
     enableRtx,
@@ -163,6 +161,19 @@ Media.createMediaConnection = (
   // we might not have any TURN server if TURN discovery failed or wasn't done or
   // we might get an empty TURN url if we land on a video mesh node
   if (turnServerInfo?.url) {
+    if (!isBrowser('firefox')) {
+      let bareTurnServer = turnServerInfo.url;
+      bareTurnServer = bareTurnServer.replace('turns:', 'turn:');
+      bareTurnServer = bareTurnServer.replace('443', '5004');
+
+      iceServers.push({
+        urls: bareTurnServer,
+        username: turnServerInfo.username || '',
+        credential: turnServerInfo.password || '',
+      });
+    }
+
+    // TURN-TLS server
     iceServers.push({
       urls: turnServerInfo.url,
       username: turnServerInfo.username || '',
@@ -179,15 +190,13 @@ Media.createMediaConnection = (
       config.bundlePolicy = bundlePolicy;
     }
 
-    const rtcMetrics = new RtcMetrics(webex, meetingId, correlationId);
-
     return new MultistreamRoapMediaConnection(
       config,
       meetingId,
       /* the rtc metrics objects callbacks */
-      (data) => rtcMetrics.addMetrics(data),
-      () => rtcMetrics.closeMetrics(),
-      () => rtcMetrics.sendMetricsInQueue()
+      (data) => rtcMetrics?.addMetrics(data),
+      () => rtcMetrics?.closeMetrics(),
+      () => rtcMetrics?.sendMetricsInQueue()
     );
   }
 

package/src/meeting/connectionStateHandler.ts

@@ -0,0 +1,65 @@
+import {MediaConnectionEventNames, ConnectionState} from '@webex/internal-media-core';
+import EventsScope from '../common/events/events-scope';
+import {Enum} from '../constants';
+
+export const ConnectionStateEvent = {
+  stateChanged: 'connectionState:changed',
+} as const;
+
+export type ConnectionStateEvent = Enum<typeof ConnectionStateEvent>;
+
+export interface ConnectionStateChangedEvent {
+  /**
+   * Current overall connection state
+   */
+  state: ConnectionState;
+}
+
+/**
+ * @class ConnectionStateHandler
+ */
+export class ConnectionStateHandler extends EventsScope {
+  private webrtcMediaConnection: any;
+
+  private mediaConnectionState: ConnectionState;
+
+  /**
+   * @param {WebRTCMeeting} webrtcMediaConnection
+   */
+  constructor(webrtcMediaConnection) {
+    super();
+
+    this.webrtcMediaConnection = webrtcMediaConnection;
+
+    this.webrtcMediaConnection.on(
+      MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED,
+      this.handleConnectionStateChange.bind(this)
+    );
+
+    this.webrtcMediaConnection.on(
+      MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED,
+      this.handleConnectionStateChange.bind(this)
+    );
+  }
+
+  /**
+   * Handler for connection state change.
+   *
+   * @returns {void}
+   */
+  private handleConnectionStateChange(): void {
+    const newConnectionState = this.webrtcMediaConnection.getConnectionState();
+
+    if (newConnectionState !== this.mediaConnectionState) {
+      this.mediaConnectionState = newConnectionState;
+      this.emit(
+        {
+          file: 'connectionStateHandler',
+          function: 'handleConnectionStateChange',
+        },
+        ConnectionStateEvent.stateChanged,
+        {state: this.mediaConnectionState}
+      );
+    }
+  }
+}