@webex/plugin-meetings 3.0.0 → 3.1.0-next.2

package/src/config.ts

@@ -87,6 +87,7 @@ export default {
       enableUnifiedMeetings: true,
       enableAdhocMeetings: true,
       enableTcpReachability: false,
+      enableTlsReachability: false,
     },
     degradationPreferences: {
       maxMacroblocksLimit: 8192,

package/src/constants.ts

@@ -1,7 +1,7 @@
 // @ts-ignore
 import {hydraTypes} from '@webex/common';
 
-type Enum<T extends Record<string, unknown>> = T[keyof T];
+export type Enum<T extends Record<string, unknown>> = T[keyof T];
 
 // *********** LOWERCASE / CAMELCASE STRINGS ************
 
@@ -196,7 +196,7 @@ export const ICE_FAIL_TIMEOUT = 3000;
 
 export const RETRY_TIMEOUT = 3000;
 
-export const ICE_AND_DTLS_CONNECTION_TIMEOUT = 10000;
+export const ICE_AND_DTLS_CONNECTION_TIMEOUT = 20000;
 export const ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT = 35000;
 
 // ******************** REGEX **********************
@@ -361,6 +361,7 @@ export const EVENT_TRIGGERS = {
   REMOTE_VIDEO_SOURCE_COUNT_CHANGED: 'media:remoteVideoSourceCountChanged',
   REMOTE_AUDIO_SOURCE_COUNT_CHANGED: 'media:remoteAudioSourceCountChanged',
   REMOTE_MEDIA_AUDIO_CREATED: 'media:remoteAudio:created',
+  REMOTE_MEDIA_INTERPRETATION_AUDIO_CREATED: 'media:remoteInterpretationAudio:created',
   REMOTE_MEDIA_SCREEN_SHARE_AUDIO_CREATED: 'media:remoteScreenShareAudio:created',
   REMOTE_MEDIA_VIDEO_LAYOUT_CHANGED: 'media:remoteVideo:layoutChanged',
   // Controls
@@ -971,7 +972,7 @@ export const SELF_ROLES = {
   COHOST: 'COHOST',
   MODERATOR: 'MODERATOR',
   ATTENDEE: 'ATTENDEE',
-  PRESENTER: 'PRESENTER',
+  PANELIST: 'PANELIST',
 };
 
 export const MEETING_STATE = {
@@ -1318,3 +1319,6 @@ export type IP_VERSION = Enum<typeof IP_VERSION>;
 // constant for if the permissionToken is about to expire in the next 30 seconds, refresh it
 export const MEETING_PERMISSION_TOKEN_REFRESH_THRESHOLD_IN_SEC = 30;
 export const MEETING_PERMISSION_TOKEN_REFRESH_REASON = 'ttl-join';
+
+// constant for named media group type
+export const NAMED_MEDIA_GROUP_TYPE_AUDIO = 1;

package/src/index.ts

@@ -4,6 +4,19 @@ import {registerPlugin} from '@webex/webex-core';
 import Meetings from './meetings';
 import config from './config';
 import {LocusRetryStatusInterceptor} from './interceptors';
+import CaptchaError from './common/errors/captcha-error';
+import IntentToJoinError from './common/errors/intent-to-join';
+import PasswordError from './common/errors/password-error';
+import PermissionError from './common/errors/permission';
+import {
+  ReclaimHostEmptyWrongKeyError,
+  ReclaimHostIsHostAlreadyError,
+  ReclaimHostNotAllowedError,
+  ReclaimHostNotSupportedError,
+} from './common/errors/reclaim-host-role-errors';
+import Meeting from './meeting';
+import MeetingInfoUtil from './meeting-info/utilv2';
+import JoinMeetingError from './common/errors/join-meeting';
 
 registerPlugin('meetings', Meetings, {
   config,
@@ -19,6 +32,7 @@ export {
   LocalSystemAudioStream,
   LocalStreamEventNames,
   StreamEventNames,
+  RemoteStreamEventNames,
   type ServerMuteReason,
   LocalMicrophoneStreamEventNames,
   LocalCameraStreamEventNames,
@@ -38,6 +52,23 @@ export default Meetings;
 
 export * as CONSTANTS from './constants';
 export * as REACTIONS from './reactions/reactions';
+export * as sdkAnnotationTypes from './annotation/annotation.types';
+export * as MeetingInfoV2 from './meeting-info/meeting-info-v2';
+export {type Reaction} from './reactions/reactions.type';
+
+export {
+  CaptchaError,
+  IntentToJoinError,
+  JoinMeetingError,
+  PasswordError,
+  PermissionError,
+  ReclaimHostIsHostAlreadyError,
+  ReclaimHostNotAllowedError,
+  ReclaimHostNotSupportedError,
+  ReclaimHostEmptyWrongKeyError,
+  Meeting,
+  MeetingInfoUtil,
+};
 
 export {RemoteMedia} from './multistream/remoteMedia';
 

package/src/interpretation/index.ts

@@ -121,14 +121,31 @@ const SimultaneousInterpretation = WebexPlugin.extend({
    * Update self's interpretation information (self is interpreter)
    * @param {Object} interpretation
    * @param {String} selfParticipantId
-   * @returns {void}
+   * @returns {bool} is target language changed
    */
   updateSelfInterpretation({interpretation, selfParticipantId}) {
+    const preTargetLanguage = this.targetLanguage;
     const {originalLanguage, sourceLanguage, order, isActive, targetLanguage, receiveLanguage} =
       interpretation || {};
     this.set({originalLanguage, sourceLanguage, order, isActive, targetLanguage, receiveLanguage});
     this.set('selfParticipantId', selfParticipantId);
+    this.set('selfIsInterpreter', !!targetLanguage);
+
+    return !!(preTargetLanguage !== targetLanguage);
   },
+
+  /**
+   * Get the language code of the interpreter target language
+   * @returns {number}
+   */
+  getTargetLanguageCode() {
+    if (this.selfIsInterpreter) {
+      return this.siLanguages.get(this.targetLanguage)?.languageCode;
+    }
+
+    return 0;
+  },
+
   /**
    * query interpretation languages
    * @returns {Promise}

package/src/locus-info/mediaSharesUtils.ts

@@ -17,6 +17,7 @@ MediaSharesUtils.parse = (mediaShares: object) => {
         url: MediaSharesUtils.getContentUrl(mediaShares),
         shareInstanceId: MediaSharesUtils.getShareInstanceId(mediaShares),
         deviceUrlSharing: MediaSharesUtils.getContentBeneficiaryDeviceUrl(mediaShares),
+        resourceType: MediaSharesUtils.getContentResourceType(mediaShares),
       },
       whiteboard: {
         beneficiaryId: MediaSharesUtils.getWhiteboardBeneficiaryId(mediaShares),
@@ -159,6 +160,21 @@ MediaSharesUtils.getContentAnnotation = (mediaShares: object) => {
   return extractContent.annotation;
 };
 
+/**
+ * get live resourceType is sharing from media shares (content)
+ * @param {Object} mediaShares
+ * @returns {Object}
+ */
+MediaSharesUtils.getContentResourceType = (mediaShares: object) => {
+  const extractContent = MediaSharesUtils.extractContent(mediaShares);
+
+  if (!extractContent || !extractContent.resourceType) {
+    return undefined;
+  }
+
+  return extractContent.resourceType;
+};
+
 /**
  * get url is sharing from media shares (content)
  * @param {Object} mediaShares

package/src/locus-info/selfUtils.ts

@@ -428,6 +428,11 @@ 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

@@ -0,0 +1,174 @@
+import {Defer} from '@webex/common';
+import {ConnectionState, Event} from '@webex/internal-media-core';
+import LoggerProxy from '../common/logs/logger-proxy';
+import {ICE_AND_DTLS_CONNECTION_TIMEOUT} from '../constants';
+
+export interface MediaConnectionAwaiterProps {
+  webrtcMediaConnection: any;
+}
+
+/**
+ * @class MediaConnectionAwaiter
+ */
+export default class MediaConnectionAwaiter {
+  private webrtcMediaConnection: any;
+  private timer: any;
+  private defer: Defer;
+  private retried: boolean;
+  private onTimeoutCallback: () => void;
+  private connectionStateCallback: () => void;
+  private iceGatheringStateCallback: () => void;
+
+  /**
+   * @param {MediaConnectionAwaiterProps} mediaConnectionAwaiterProps
+   */
+  constructor({webrtcMediaConnection}: MediaConnectionAwaiterProps) {
+    this.webrtcMediaConnection = webrtcMediaConnection;
+    this.defer = new Defer();
+    this.retried = false;
+    this.onTimeoutCallback = this.onTimeout.bind(this);
+    this.connectionStateCallback = this.connectionStateListenerCallback.bind(this);
+    this.iceGatheringStateCallback = this.iceGatheringStateListenerCallback.bind(this);
+  }
+
+  /**
+   * Returns true if the connection is connected, false otherwise.
+   *
+   * @returns {boolean}
+   */
+  private isConnected(): boolean {
+    return this.webrtcMediaConnection.getConnectionState() === ConnectionState.Connected;
+  }
+
+  /**
+   * Returns true if the ICE Gathering is completed, false otherwise.
+   *
+   * @returns {boolean}
+   */
+  private isIceGatheringCompleted(): boolean {
+    return this.webrtcMediaConnection.getIceGatheringState() === 'complete';
+  }
+
+  /**
+   * Clears the callbacks.
+   *
+   * @returns {void}
+   */
+  private clearCallbacks(): void {
+    this.webrtcMediaConnection.off(
+      Event.ICE_GATHERING_STATE_CHANGED,
+      this.iceGatheringStateCallback
+    );
+    this.webrtcMediaConnection.off(Event.CONNECTION_STATE_CHANGED, this.connectionStateCallback);
+  }
+
+  /**
+   * Listener for connection state change.
+   *
+   * @returns {void}
+   */
+  connectionStateListenerCallback(): void {
+    LoggerProxy.logger.log(
+      `Media:MediaConnectionAwaiter#connectionStateListenerCallback --> connection state: ${this.webrtcMediaConnection.getConnectionState()}`
+    );
+
+    if (!this.isConnected()) {
+      return;
+    }
+
+    clearTimeout(this.timer);
+
+    this.clearCallbacks();
+
+    this.defer.resolve();
+  }
+
+  /**
+   * Listener for ICE gathering state change.
+   *
+   * @returns {void}
+   */
+  iceGatheringStateListenerCallback(): void {
+    const iceGatheringState = this.webrtcMediaConnection.getIceGatheringState();
+
+    LoggerProxy.logger.log(
+      `Media:MediaConnectionAwaiter#iceGatheringStateListenerCallback --> ICE gathering state change -> ${iceGatheringState}`
+    );
+
+    if (!this.isIceGatheringCompleted()) {
+      return;
+    }
+
+    if (this.isConnected()) {
+      return;
+    }
+
+    clearTimeout(this.timer);
+
+    this.timer = setTimeout(this.onTimeoutCallback, ICE_AND_DTLS_CONNECTION_TIMEOUT);
+  }
+
+  /**
+   * Function called when the timeout is reached.
+   *
+   * @returns {void}
+   */
+  onTimeout(): void {
+    if (this.isConnected()) {
+      this.clearCallbacks();
+
+      this.defer.resolve();
+
+      return;
+    }
+
+    if (!this.isIceGatheringCompleted()) {
+      if (!this.retried) {
+        LoggerProxy.logger.warn(
+          'Media:MediaConnectionAwaiter#onTimeout --> ICE gathering did not complete within the timeout for the first time, retrying once'
+        );
+
+        // retry once if ICE gathering is not completed
+        this.retried = true;
+        clearTimeout(this.timer);
+        this.timer = setTimeout(this.onTimeoutCallback, ICE_AND_DTLS_CONNECTION_TIMEOUT);
+
+        return;
+      }
+
+      LoggerProxy.logger.warn(
+        'Media:MediaConnectionAwaiter#onTimeout --> ICE gathering did not complete within the timeout for the second time, rejecting'
+      );
+    } else {
+      LoggerProxy.logger.warn(
+        'Media:MediaConnectionAwaiter#onTimeout --> ICE gathering completed, but connection state is not connected, rejecting'
+      );
+    }
+
+    this.clearCallbacks();
+
+    this.defer.reject();
+  }
+
+  /**
+   * Waits for the webrtc media connection to be connected.
+   *
+   * @returns {Promise}
+   */
+  waitForMediaConnectionConnected(): Promise<void> {
+    if (this.isConnected()) {
+      return Promise.resolve();
+    }
+
+    this.webrtcMediaConnection.on(Event.CONNECTION_STATE_CHANGED, this.connectionStateCallback);
+
+    this.webrtcMediaConnection.on(
+      Event.ICE_GATHERING_STATE_CHANGED,
+      this.iceGatheringStateCallback
+    );
+
+    this.timer = setTimeout(this.onTimeoutCallback, ICE_AND_DTLS_CONNECTION_TIMEOUT);
+
+    return this.defer.promise;
+  }
+}

package/src/media/index.ts

@@ -160,7 +160,9 @@ Media.createMediaConnection = (
 
   const iceServers = [];
 
-  if (turnServerInfo) {
+  // 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) {
     iceServers.push({
       urls: turnServerInfo.url,
       username: turnServerInfo.username || '',

package/src/media/properties.ts

@@ -1,5 +1,3 @@
-import {ConnectionState, Event} from '@webex/internal-media-core';
-
 import {
   LocalCameraStream,
   LocalMicrophoneStream,
@@ -8,8 +6,9 @@ import {
   RemoteStream,
 } from '@webex/media-helpers';
 
-import {MEETINGS, ICE_AND_DTLS_CONNECTION_TIMEOUT, QUALITY_LEVELS} from '../constants';
+import {MEETINGS, QUALITY_LEVELS} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
+import MediaConnectionAwaiter from './MediaConnectionAwaiter';
 
 export type MediaDirection = {
   sendAudio: boolean;
@@ -175,35 +174,11 @@ export default class MediaProperties {
    * @returns {Promise<void>}
    */
   waitForMediaConnectionConnected(): Promise<void> {
-    const isConnected = () =>
-      this.webrtcMediaConnection.getConnectionState() === ConnectionState.Connected;
-
-    if (isConnected()) {
-      return Promise.resolve();
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      let timer;
-
-      const connectionStateListener = () => {
-        LoggerProxy.logger.log(
-          `Media:properties#waitForMediaConnectionConnected --> connection state: ${this.webrtcMediaConnection.getConnectionState()}`
-        );
-
-        if (isConnected()) {
-          clearTimeout(timer);
-          this.webrtcMediaConnection.off(Event.CONNECTION_STATE_CHANGED, connectionStateListener);
-          resolve();
-        }
-      };
-
-      timer = setTimeout(() => {
-        this.webrtcMediaConnection.off(Event.CONNECTION_STATE_CHANGED, connectionStateListener);
-        reject();
-      }, ICE_AND_DTLS_CONNECTION_TIMEOUT);
-
-      this.webrtcMediaConnection.on(Event.CONNECTION_STATE_CHANGED, connectionStateListener);
+    const mediaConnectionAwaiter = new MediaConnectionAwaiter({
+      webrtcMediaConnection: this.webrtcMediaConnection,
     });
+
+    return mediaConnectionAwaiter.waitForMediaConnectionConnected();
   }
 
   /**