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

package/src/multistream/remoteMediaManager.ts

@@ -1,7 +1,7 @@
 /* eslint-disable valid-jsdoc */
 import {cloneDeep, forEach, remove} from 'lodash';
 import {EventMap} from 'typed-emitter';
-import {MediaType} from '@webex/internal-media-core';
+import {MediaType, NamedMediaGroup} from '@webex/internal-media-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import EventsScope from '../common/events/events-scope';
@@ -11,6 +11,7 @@ import {ReceiveSlot, CSI} from './receiveSlot';
 import {ReceiveSlotManager} from './receiveSlotManager';
 import {RemoteMediaGroup} from './remoteMediaGroup';
 import {MediaRequestManager} from './mediaRequestManager';
+import {NAMED_MEDIA_GROUP_TYPE_AUDIO} from '../constants';
 
 export type PaneSize = RemoteVideoResolution;
 export type LayoutId = string;
@@ -49,6 +50,7 @@ export interface Configuration {
 
     layouts: {[key: LayoutId]: VideoLayout}; // a map of all available layouts, a layout can be set via setLayout() method
   };
+  namedMediaGroup?: NamedMediaGroup;
 }
 
 /* Predefined layouts: */
@@ -173,6 +175,7 @@ export const DefaultConfiguration: Configuration = {
 export enum Event {
   // events for audio streams
   AudioCreated = 'AudioCreated',
+  InterpretationAudioCreated = 'InterpretationAudioCreated',
   ScreenShareAudioCreated = 'ScreenShareAudioCreated',
 
   // events for video streams
@@ -221,7 +224,10 @@ export class RemoteMediaManager extends EventsScope {
   private currentLayout?: VideoLayout;
 
   private slots: {
-    audio: ReceiveSlot[];
+    audio: {
+      main: ReceiveSlot[];
+      si: ReceiveSlot;
+    };
     screenShare: {
       audio: ReceiveSlot[];
       video?: ReceiveSlot;
@@ -234,7 +240,10 @@ export class RemoteMediaManager extends EventsScope {
   };
 
   private media: {
-    audio?: RemoteMediaGroup;
+    audio: {
+      main?: RemoteMediaGroup;
+      si?: RemoteMediaGroup;
+    };
     video: {
       activeSpeakerGroups: {
         [key: PaneGroupId]: RemoteMediaGroup;
@@ -277,7 +286,10 @@ export class RemoteMediaManager extends EventsScope {
     this.receiveSlotManager = receiveSlotManager;
     this.mediaRequestManagers = mediaRequestManagers;
     this.media = {
-      audio: undefined,
+      audio: {
+        main: undefined,
+        si: undefined,
+      },
       video: {
         activeSpeakerGroups: {},
         memberPanes: {},
@@ -291,7 +303,10 @@ export class RemoteMediaManager extends EventsScope {
     this.checkConfigValidity();
 
     this.slots = {
-      audio: [],
+      audio: {
+        main: [],
+        si: undefined,
+      },
       screenShare: {
         audio: [],
         video: undefined,
@@ -389,8 +404,11 @@ export class RemoteMediaManager extends EventsScope {
     });
 
     // release all audio receive slots
-    this.slots.audio.forEach((slot) => this.receiveSlotManager.releaseSlot(slot));
-    this.slots.audio.length = 0;
+    this.slots.audio.main.forEach((slot) => this.receiveSlotManager.releaseSlot(slot));
+    this.slots.audio.main.length = 0;
+    if (this.slots.audio.si) {
+      this.receiveSlotManager.releaseSlot(this.slots.audio.si);
+    }
 
     // release screen share slots
     this.slots.screenShare.audio.forEach((slot) => this.receiveSlotManager.releaseSlot(slot));
@@ -525,22 +543,54 @@ export class RemoteMediaManager extends EventsScope {
     this.mediaRequestManagers.video.commit();
   }
 
+  /**
+   * Sets which named media group need receiving
+   * @param {MediaType} mediaType of the stream
+   * @param {number} languageCode of the stream. If the languageId is 0, the named media group request will be canceled,
+   * and only receive the main audio stream.
+   * @returns {void}
+   */
+  public async setReceiveNamedMediaGroup(mediaType: MediaType, languageId: number) {
+    if (mediaType !== MediaType.AudioMain) {
+      throw new Error(`cannot set receive named media group which media type is ${mediaType}`);
+    }
+
+    const value = languageId;
+    if (value === this.config.namedMediaGroup?.value) {
+      return;
+    }
+
+    this.config.namedMediaGroup = {
+      type: NAMED_MEDIA_GROUP_TYPE_AUDIO,
+      value,
+    };
+
+    if (!this.media.audio.si) {
+      await this.createInterpretationAudioMedia(true);
+    } else {
+      this.media.audio.si.setNamedMediaGroup(this.config.namedMediaGroup, true);
+    }
+  }
+
   /**
    * Creates the audio slots
    */
   private async createAudioMedia() {
-    // create the audio receive slots
+    // create si audio request
+    await this.createInterpretationAudioMedia(false);
+
+    // create main audio receive slots
     for (let i = 0; i < this.config.audio.numOfActiveSpeakerStreams; i += 1) {
       // eslint-disable-next-line no-await-in-loop
       const slot = await this.receiveSlotManager.allocateSlot(MediaType.AudioMain);
 
-      this.slots.audio.push(slot);
+      this.slots.audio.main.push(slot);
     }
 
-    // create a remote media group
-    this.media.audio = new RemoteMediaGroup(
+    // create a remote media group for main audio
+    this.media.audio.main = new RemoteMediaGroup(
       this.mediaRequestManagers.audio,
-      this.slots.audio,
+      this.slots.audio.main,
       255,
       true
     );
@@ -548,10 +598,40 @@ export class RemoteMediaManager extends EventsScope {
     this.emit(
       {file: 'multistream/remoteMediaManager', function: 'createAudioMedia'},
       Event.AudioCreated,
-      this.media.audio
+      this.media.audio.main
     );
   }
 
+  /**
+   * Creates the audio slots for named media
+   */
+  private async createInterpretationAudioMedia(commitRequest: boolean) {
+    // create slot for interpretation language audio
+    if (
+      this.config.namedMediaGroup?.type === NAMED_MEDIA_GROUP_TYPE_AUDIO &&
+      this.config.namedMediaGroup?.value
+    ) {
+      this.slots.audio.si = await this.receiveSlotManager.allocateSlot(MediaType.AudioMain);
+
+      // create a remote media group for si audio
+      this.media.audio.si = new RemoteMediaGroup(
+        this.mediaRequestManagers.audio,
+        [this.slots.audio.si],
+        255,
+        commitRequest,
+        {
+          namedMediaGroup: this.config.namedMediaGroup,
+        }
+      );
+
+      this.emit(
+        {file: 'multistream/remoteMediaManager', function: 'createInterpretationAudioMedia'},
+        Event.InterpretationAudioCreated,
+        this.media.audio.si
+      );
+    }
+  }
+
   /**
    * Creates receive slots required for receiving screen share audio and video
    */
@@ -748,7 +828,7 @@ export class RemoteMediaManager extends EventsScope {
   /** logs main audio slots */
   private logMainAudioReceiveSlots() {
     LoggerProxy.logger.log(
-      `RemoteMediaManager#logMainAudioReceiveSlots --> MAIN AUDIO receive slots: ${this.slots.audio
+      `RemoteMediaManager#logMainAudioReceiveSlots --> MAIN AUDIO receive slots: ${this.slots.audio.main
         .map((slot) => slot.logString)
         .join(', ')}`
     );
@@ -924,8 +1004,13 @@ export class RemoteMediaManager extends EventsScope {
   }) {
     const {audio, video, screenShareAudio, screenShareVideo, commit} = options;
 
-    if (audio && this.media.audio) {
-      this.media.audio.stop(commit);
+    if (audio) {
+      if (this.media.audio.main) {
+        this.media.audio.main.stop(commit);
+      }
+      if (this.media.audio.si) {
+        this.media.audio.si.stop(commit);
+      }
     }
     if (video) {
       Object.values(this.media.video.activeSpeakerGroups).forEach((remoteMediaGroup) => {

package/src/multistream/sendSlotManager.ts

@@ -3,6 +3,7 @@ import {
   MediaType,
   LocalStream,
   MultistreamRoapMediaConnection,
+  NamedMediaGroup,
 } from '@webex/internal-media-core';
 
 export default class SendSlotManager {
@@ -55,6 +56,33 @@ export default class SendSlotManager {
     return slot;
   }
 
+  /**
+   * Allow users to specify 'namedMediaGroups' to indicate which named media group its audio should be sent to.
+   * @param {MediaType} mediaType MediaType of the sendSlot to which the audio stream needs to be send to the media group
+   * @param {[]}namedMediaGroups - Allow users to specify 'namedMediaGroups'.If the value of 'namedMediaGroups' is zero,
+   * named media group will be canceled and the audio stream will be sent to the floor.
+   * @returns {void}
+   */
+  public setNamedMediaGroups(mediaType: MediaType, namedMediaGroups: NamedMediaGroup[]) {
+    if (mediaType !== MediaType.AudioMain) {
+      throw new Error(
+        `sendSlotManager cannot set named media group which media type is ${mediaType}`
+      );
+    }
+
+    const slot = this.slots.get(mediaType);
+
+    if (!slot) {
+      throw new Error(`Slot for ${mediaType} does not exist`);
+    }
+
+    slot.setNamedMediaGroups(namedMediaGroups);
+
+    this.LoggerProxy.logger.info(
+      `SendSlotsManager->setNamedMediaGroups#set named media group ${namedMediaGroups}`
+    );
+  }
+
   /**
    * This method publishes the given stream to the sendSlot for the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot to which a stream needs to be published (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)

package/src/reachability/clusterReachability.ts

@@ -2,7 +2,7 @@ import {Defer} from '@webex/common';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import {ClusterNode} from './request';
-import {convertStunUrlToTurn} from './util';
+import {convertStunUrlToTurn, convertStunUrlToTurnTls} from './util';
 
 import {ICE_GATHERING_STATE, CONNECTION_STATE} from '../constants';
 
@@ -29,6 +29,7 @@ export type ClusterReachabilityResult = {
 export class ClusterReachability {
   private numUdpUrls: number;
   private numTcpUrls: number;
+  private numXTlsUrls: number;
   private result: ClusterReachabilityResult;
   private pc?: RTCPeerConnection;
   private defer: Defer; // this defer is resolved once reachability checks for this cluster are completed
@@ -46,6 +47,7 @@ export class ClusterReachability {
     this.isVideoMesh = clusterInfo.isVideoMesh;
     this.numUdpUrls = clusterInfo.udp.length;
     this.numTcpUrls = clusterInfo.tcp.length;
+    this.numXTlsUrls = clusterInfo.xtls.length;
 
     this.pc = this.createPeerConnection(clusterInfo);
 
@@ -94,8 +96,16 @@ export class ClusterReachability {
       };
     });
 
+    const turnTlsIceServers = cluster.xtls.map((urlString: string) => {
+      return {
+        username: 'webexturnreachuser',
+        credential: 'webexturnreachpwd',
+        urls: [convertStunUrlToTurnTls(urlString)],
+      };
+    });
+
     return {
-      iceServers: [...udpIceServers, ...tcpIceServers],
+      iceServers: [...udpIceServers, ...tcpIceServers, ...turnTlsIceServers],
       iceCandidatePoolSize: 0,
       iceTransportPolicy: 'all',
     };
@@ -194,7 +204,7 @@ export class ClusterReachability {
    * @returns {boolean} true if we have all results, false otherwise
    */
   private haveWeGotAllResults(): boolean {
-    return ['udp', 'tcp'].every(
+    return ['udp', 'tcp', 'xtls'].every(
       (protocol) =>
         this.result[protocol].result === 'reachable' || this.result[protocol].result === 'untested'
     );
@@ -207,7 +217,7 @@ export class ClusterReachability {
    * @param {number} latency
    * @returns {void}
    */
-  private storeLatencyResult(protocol: 'udp' | 'tcp', latency: number) {
+  private storeLatencyResult(protocol: 'udp' | 'tcp' | 'xtls', latency: number) {
     const result = this.result[protocol];
 
     if (result.latencyInMilliseconds === undefined) {
@@ -227,6 +237,7 @@ export class ClusterReachability {
    */
   private registerIceCandidateListener() {
     this.pc.onicecandidate = (e) => {
+      const TURN_TLS_PORT = 443;
       const CANDIDATE_TYPES = {
         SERVER_REFLEXIVE: 'srflx',
         RELAY: 'relay',
@@ -239,7 +250,8 @@ export class ClusterReachability {
         }
 
         if (e.candidate.type === CANDIDATE_TYPES.RELAY) {
-          this.storeLatencyResult('tcp', this.getElapsedTime());
+          const protocol = e.candidate.port === TURN_TLS_PORT ? 'xtls' : 'tcp';
+          this.storeLatencyResult(protocol, this.getElapsedTime());
           // we don't add public IP for TCP, because in the case of relay candidates
           // e.candidate.address is the TURN server address, not the client's public IP
         }
@@ -275,6 +287,9 @@ export class ClusterReachability {
     this.result.tcp = {
       result: this.numTcpUrls > 0 ? 'unreachable' : 'untested',
     };
+    this.result.xtls = {
+      result: this.numXTlsUrls > 0 ? 'unreachable' : 'untested',
+    };
 
     try {
       const offer = await this.pc.createOffer({offerToReceiveAudio: true});

package/src/reachability/index.ts

@@ -22,10 +22,14 @@ export type ReachabilityMetrics = {
   reachability_public_udp_failed: number;
   reachability_public_tcp_success: number;
   reachability_public_tcp_failed: number;
+  reachability_public_xtls_success: number;
+  reachability_public_xtls_failed: number;
   reachability_vmn_udp_success: number;
   reachability_vmn_udp_failed: number;
   reachability_vmn_tcp_success: number;
   reachability_vmn_tcp_failed: number;
+  reachability_vmn_xtls_success: number;
+  reachability_vmn_xtls_failed: number;
 };
 
 /**
@@ -141,10 +145,14 @@ export default class Reachability {
       reachability_public_udp_failed: 0,
       reachability_public_tcp_success: 0,
       reachability_public_tcp_failed: 0,
+      reachability_public_xtls_success: 0,
+      reachability_public_xtls_failed: 0,
       reachability_vmn_udp_success: 0,
       reachability_vmn_udp_failed: 0,
       reachability_vmn_tcp_success: 0,
       reachability_vmn_tcp_failed: 0,
+      reachability_vmn_xtls_success: 0,
+      reachability_vmn_xtls_failed: 0,
     };
 
     const updateStats = (clusterType: 'public' | 'vmn', result: ClusterReachabilityResult) => {
@@ -156,6 +164,10 @@ export default class Reachability {
         const outcome = result.tcp.result === 'reachable' ? 'success' : 'failed';
         stats[`reachability_${clusterType}_tcp_${outcome}`] += 1;
       }
+      if (result.xtls && result.xtls.result !== 'untested') {
+        const outcome = result.xtls.result === 'reachable' ? 'success' : 'failed';
+        stats[`reachability_${clusterType}_xtls_${outcome}`] += 1;
+      }
     };
 
     try {
@@ -338,7 +350,10 @@ export default class Reachability {
     LoggerProxy.logger.log(
       `Reachability:index#performReachabilityChecks --> doing UDP${
         // @ts-ignore
-        this.webex.config.meetings.experimental.enableTcpReachability ? ' and TCP' : ''
+        this.webex.config.meetings.experimental.enableTcpReachability ? ',TCP' : ''
+      }${
+        // @ts-ignore
+        this.webex.config.meetings.experimental.enableTlsReachability ? ',TLS' : ''
       } reachability checks`
     );
 
@@ -354,6 +369,14 @@ export default class Reachability {
         cluster.tcp = [];
       }
 
+      const includeTlsReachability =
+        // @ts-ignore
+        this.webex.config.meetings.experimental.enableTlsReachability && !cluster.isVideoMesh;
+
+      if (!includeTlsReachability) {
+        cluster.xtls = [];
+      }
+
       this.clusterReachability[key] = new ClusterReachability(key, cluster);
 
       return this.clusterReachability[key].start().then((result) => {

package/src/reachability/request.ts

@@ -34,17 +34,21 @@ class ReachabilityRequest {
    * @returns {Promise}
    */
   getClusters = (ipVersion?: IP_VERSION): Promise<{clusters: ClusterList; joinCookie: any}> =>
-    this.webex
-      .request({
-        method: HTTP_VERBS.GET,
-        shouldRefreshAccessToken: false,
-        api: API.CALLIOPEDISCOVERY,
-        resource: RESOURCE.CLUSTERS,
-        qs: {
-          JCSupport: 1,
-          ipver: ipVersion,
-        },
-      })
+    this.webex.internal.newMetrics.callDiagnosticLatencies
+      .measureLatency(
+        () =>
+          this.webex.request({
+            method: HTTP_VERBS.GET,
+            shouldRefreshAccessToken: false,
+            api: API.CALLIOPEDISCOVERY,
+            resource: RESOURCE.CLUSTERS,
+            qs: {
+              JCSupport: 1,
+              ipver: ipVersion,
+            },
+          }),
+        'internal.get.cluster.time'
+      )
       .then((res) => {
         const {clusters, joinCookie} = res.body;
 

package/src/reachability/util.ts

@@ -22,3 +22,24 @@ export function convertStunUrlToTurn(stunUrl: string, protocol: 'udp' | 'tcp') {
 
   return url.toString();
 }
+
+/**
+ * Converts a stun url to a turns url
+ *
+ * @param {string} stunUrl url of a stun server
+ * @returns {string} url of a turns server
+ */
+export function convertStunUrlToTurnTls(stunUrl: string) {
+  // stunUrl looks like this: "stun:external-media1.public.wjfkm-a-15.prod.infra.webex.com:443"
+  // and we need it to be like this: "turns:external-media1.public.wjfkm-a-15.prod.infra.webex.com:443?transport=tcp"
+  const url = new URL(stunUrl);
+
+  if (url.protocol !== 'stun:') {
+    throw new Error(`Not a STUN URL: ${stunUrl}`);
+  }
+
+  url.protocol = 'turns:';
+  url.searchParams.append('transport', 'tcp');
+
+  return url.toString();
+}

package/src/reconnection-manager/index.ts

@@ -568,7 +568,7 @@ export default class ReconnectionManager {
 
     const iceServers = [];
 
-    if (turnServerResult.turnServerInfo) {
+    if (turnServerResult.turnServerInfo?.url) {
       iceServers.push({
         urls: turnServerResult.turnServerInfo.url,
         username: turnServerResult.turnServerInfo.username || '',

package/src/roap/index.ts

@@ -5,12 +5,18 @@ import {ROAP} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import RoapRequest from './request';
-import TurnDiscovery from './turnDiscovery';
+import TurnDiscovery, {TurnDiscoveryResult} from './turnDiscovery';
 import Meeting from '../meeting';
 import MeetingUtil from '../meeting/util';
 import Metrics from '../metrics';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 
+export {
+  type TurnDiscoveryResult,
+  type TurnServerInfo,
+  type TurnDiscoverySkipReason,
+} from './turnDiscovery';
+
 /**
  * Roap options
  * @typedef {Object} RoapOptions
@@ -39,7 +45,7 @@ export default class Roap extends StatelessWebexPlugin {
   options: any;
   roapHandler: any;
   roapRequest: any;
-  turnDiscovery: any;
+  turnDiscovery: TurnDiscovery;
 
   /**
    *
@@ -260,7 +266,23 @@ export default class Roap extends StatelessWebexPlugin {
    * @param {Boolean} [isForced]
    * @returns {Promise}
    */
-  doTurnDiscovery(meeting: Meeting, isReconnecting: boolean, isForced?: boolean) {
+  doTurnDiscovery(
+    meeting: Meeting,
+    isReconnecting: boolean,
+    isForced?: boolean
+  ): Promise<TurnDiscoveryResult> {
     return this.turnDiscovery.doTurnDiscovery(meeting, isReconnecting, isForced);
   }
+
+  generateTurnDiscoveryRequestMessage(meeting: Meeting, isForced: boolean) {
+    return this.turnDiscovery.generateTurnDiscoveryRequestMessage(meeting, isForced);
+  }
+
+  handleTurnDiscoveryHttpResponse(meeting: Meeting, httpResponse: object) {
+    return this.turnDiscovery.handleTurnDiscoveryHttpResponse(meeting, httpResponse);
+  }
+
+  abortTurnDiscovery() {
+    return this.turnDiscovery.abort();
+  }
 }

package/src/roap/request.ts

@@ -123,7 +123,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
         );
         const {locus} = res.body;
 
-        locus.roapSeq = roapMessage.seq;
+        locus.roapSeq = options.roapMessage.seq;
 
         return {
           locus,
@@ -139,9 +139,9 @@ export default class RoapRequest extends StatelessWebexPlugin {
             rawError: err,
           },
         });
-        LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`);
+        LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:`, err);
         LoggerProxy.logger.error(
-          `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(
+          `Roap:request#sendRoapRequest --> roapMessage that caused error:${JSON.stringify(
             roapMessage,
             null,
             2