@webex/plugin-meetings 3.0.0-beta.24 → 3.0.0-beta.241

package/src/media/index.ts

@@ -4,15 +4,27 @@
 /* globals navigator */
 
 import {RoapMediaConnection, MultistreamRoapMediaConnection} from '@webex/internal-media-core';
+import {
+  LocalCameraTrack,
+  LocalDisplayTrack,
+  LocalSystemAudioTrack,
+  LocalMicrophoneTrack,
+} from '@webex/media-helpers';
 import LoggerProxy from '../common/logs/logger-proxy';
-import {AUDIO_INPUT, VIDEO_INPUT, MEDIA_TRACK_CONSTRAINT} from '../constants';
+import {MEDIA_TRACK_CONSTRAINT} from '../constants';
 import Config from '../config';
 import StaticConfig from '../common/config';
-import MediaError from '../common/errors/media';
 import BrowserDetection from '../common/browser-detection';
+import RtcMetrics from '../rtcMetrics';
 
 const {isBrowser} = BrowserDetection();
 
+type MultistreamConnectionConfig = ConstructorParameters<typeof MultistreamRoapMediaConnection>[0];
+
+export type BundlePolicy = ConstructorParameters<
+  typeof MultistreamRoapMediaConnection
+>[0]['bundlePolicy'];
+
 /**
  * MediaDirection
  * @typedef {Object} MediaDirection
@@ -43,45 +55,6 @@ const {isBrowser} = BrowserDetection();
  */
 const Media: any = {};
 
-/**
- * @param {boolean} enabled
- * @param {MediaStreamTrack} track
- * @returns {Boolean}
- * @public
- */
-Media.setLocalTrack = (enabled: boolean, track: MediaStreamTrack) => {
-  if (track) {
-    track.enabled = enabled;
-
-    return true;
-  }
-
-  return false;
-};
-
-/**
- * format the media array for send
- * @param {String} mediaId
- * @param {Boolean} audioMuted
- * @param {Boolean} videoMuted
- * @returns {Array} medias
- */
-Media.generateLocalMedias = (mediaId: string, audioMuted: boolean, videoMuted: boolean) => {
-  if (mediaId) {
-    return [
-      {
-        localSdp: JSON.stringify({
-          audioMuted,
-          videoMuted,
-        }),
-        mediaId,
-      },
-    ];
-  }
-
-  return [];
-};
-
 /**
  * make a browser call to get the media
  * @param {SendOptions} options
@@ -109,33 +82,60 @@ Media.getLocalMedia = (options: any, config: object) => {
   return Promise.resolve(undefined);
 };
 
+Media.getDirection = (forceSendRecv: boolean, receive: boolean, send: boolean) => {
+  if (!receive && !send) {
+    return 'inactive';
+  }
+
+  if (forceSendRecv || (receive && send)) {
+    return 'sendrecv';
+  }
+
+  if (receive) {
+    return 'recvonly';
+  }
+
+  return 'sendonly';
+};
+
 /**
  * creates a webrtc media connection with provided tracks and mediaDirection configuration
  *
  * @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] only applicable to non-multistream connections, contains mediaDirection and local tracks:
- *                                 audioTrack, videoTrack and shareTrack
+ * @param {Object} [options.mediaProperties] contains mediaDirection and local tracks:
+ *                                 audioTrack, videoTrack, shareVideoTrack, and shareAudioTrack
  * @param {string} [options.remoteQualityLevel] LOW|MEDIUM|HIGH applicable only to non-multistream connections
  * @param {boolean} [options.enableRtx] applicable only to non-multistream connections
  * @param {boolean} [options.enableExtmap] applicable only to non-multistream connections
  * @param {Object} [options.turnServerInfo]
- * @returns {RoapMediaConnection}
+ * @param {BundlePolicy} [options.bundlePolicy]
+ * @returns {RoapMediaConnection | MultistreamRoapMediaConnection}
  */
 Media.createMediaConnection = (
   isMultistream: boolean,
   debugId: string,
+  webex: object,
+  meetingId: string,
+  correlationId: string,
   options: {
-    mediaProperties?: {
+    mediaProperties: {
       mediaDirection?: {
         receiveAudio: boolean;
         receiveVideo: boolean;
         receiveShare: boolean;
+        sendAudio: boolean;
+        sendVideo: boolean;
+        sendShare: boolean;
       };
-      audioTrack?: MediaStreamTrack;
-      videoTrack?: MediaStreamTrack;
-      shareTrack?: MediaStreamTrack;
+      audioTrack?: LocalMicrophoneTrack;
+      videoTrack?: LocalCameraTrack;
+      shareVideoTrack?: LocalDisplayTrack;
+      shareAudioTrack?: LocalSystemAudioTrack;
     };
     remoteQualityLevel?: 'LOW' | 'MEDIUM' | 'HIGH';
     enableRtx?: boolean;
@@ -145,9 +145,17 @@ Media.createMediaConnection = (
       username: string;
       password: string;
     };
+    bundlePolicy?: BundlePolicy;
   }
 ) => {
-  const {mediaProperties, remoteQualityLevel, enableRtx, enableExtmap, turnServerInfo} = options;
+  const {
+    mediaProperties,
+    remoteQualityLevel,
+    enableRtx,
+    enableExtmap,
+    turnServerInfo,
+    bundlePolicy,
+  } = options;
 
   const iceServers = [];
 
@@ -160,11 +168,25 @@ Media.createMediaConnection = (
   }
 
   if (isMultistream) {
+    const config: MultistreamConnectionConfig = {
+      iceServers,
+      enableMainAudio:
+        mediaProperties.mediaDirection?.sendAudio || mediaProperties.mediaDirection?.receiveAudio,
+      enableMainVideo:
+        mediaProperties.mediaDirection?.sendVideo || mediaProperties.mediaDirection?.receiveVideo,
+    };
+
+    if (bundlePolicy) {
+      config.bundlePolicy = bundlePolicy;
+    }
+
+    const rtcMetrics = new RtcMetrics(webex, meetingId, correlationId);
+
     return new MultistreamRoapMediaConnection(
-      {
-        iceServers,
-      },
-      debugId
+      config,
+      meetingId,
+      (data) => rtcMetrics.addMetrics(data),
+      () => rtcMetrics.closeMetrics()
     );
   }
 
@@ -172,7 +194,7 @@ Media.createMediaConnection = (
     throw new Error('mediaProperties have to be provided for non-multistream media connections');
   }
 
-  const {mediaDirection, audioTrack, videoTrack, shareTrack} = mediaProperties;
+  const {mediaDirection, audioTrack, videoTrack, shareVideoTrack} = mediaProperties;
 
   return new RoapMediaConnection(
     {
@@ -193,17 +215,21 @@ Media.createMediaConnection = (
       },
     },
     {
-      send: {
-        audio: audioTrack,
-        video: videoTrack,
-        screenShareVideo: shareTrack,
+      localTracks: {
+        audio: audioTrack?.underlyingTrack,
+        video: videoTrack?.underlyingTrack,
+        screenShareVideo: shareVideoTrack?.underlyingTrack,
       },
-      receive: {
-        audio: mediaDirection.receiveAudio,
-        video: mediaDirection.receiveVideo,
-        screenShareVideo: mediaDirection.receiveShare,
-        remoteQualityLevel,
+      direction: {
+        audio: Media.getDirection(true, mediaDirection.receiveAudio, mediaDirection.sendAudio),
+        video: Media.getDirection(true, mediaDirection.receiveVideo, mediaDirection.sendVideo),
+        screenShareVideo: Media.getDirection(
+          false,
+          mediaDirection.receiveShare,
+          mediaDirection.sendShare
+        ),
       },
+      remoteQualityLevel,
     },
     debugId
   );
@@ -348,52 +374,6 @@ Media.getMedia = (audio: any | boolean, video: any | boolean, config: any) => {
   });
 };
 
-/**
- * Checks if the machine has at least one audio or video device (Dont use this for screen share)
- * @param {object} [options]
- * {
- *    sendAudio: true/false,
- *    sendVideo: true/false
- * }
- * @returns {Object} {
- *    sendAudio: true/false,
- *    sendVideo: true/false
- *}
- */
-Media.getSupportedDevice = ({sendAudio, sendVideo}: {sendAudio: boolean; sendVideo: boolean}) =>
-  Promise.resolve().then(() => {
-    if (!navigator.mediaDevices || navigator.mediaDevices.enumerateDevices === undefined) {
-      return {
-        sendAudio: false,
-        sendVideo: false,
-      };
-    }
-
-    return navigator.mediaDevices.enumerateDevices().then((devices) => {
-      const supported = {
-        audio: devices.filter((device) => device.kind === AUDIO_INPUT).length > 0,
-        video: devices.filter((device) => device.kind === VIDEO_INPUT).length > 0,
-      };
-
-      return {
-        sendAudio: supported.audio && sendAudio,
-        sendVideo: supported.video && sendVideo,
-      };
-    });
-  });
-
-/**
- * proxy to browser navigator.mediaDevices.enumerateDevices()
- * @returns {Promise}
- */
-Media.getDevices = () => {
-  if (navigator && navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
-    return navigator.mediaDevices.enumerateDevices();
-  }
-
-  return Promise.reject(new MediaError('enumerateDevices not supported.'));
-};
-
 /**
  *
  * Toggle a specific stream

package/src/media/properties.ts

@@ -1,41 +1,64 @@
 import {ConnectionState, Event} from '@webex/internal-media-core';
 
+import {
+  LocalCameraTrack,
+  LocalMicrophoneTrack,
+  LocalDisplayTrack,
+  LocalSystemAudioTrack,
+} from '@webex/media-helpers';
+
 import {MEETINGS, PC_BAIL_TIMEOUT, QUALITY_LEVELS} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 
+export type MediaDirection = {
+  sendAudio: boolean;
+  sendVideo: boolean;
+  sendShare: boolean;
+  receiveAudio: boolean;
+  receiveVideo: boolean;
+  receiveShare: boolean;
+};
+
 /**
  * @class MediaProperties
  */
 export default class MediaProperties {
-  audioTrack: any;
-  localQualityLevel: any;
-  mediaDirection: any;
+  audioTrack?: LocalMicrophoneTrack;
+  mediaDirection: MediaDirection;
   mediaSettings: any;
   webrtcMediaConnection: any;
   remoteAudioTrack: any;
   remoteQualityLevel: any;
   remoteShare: any;
   remoteVideoTrack: any;
-  shareTrack: any;
+  shareVideoTrack?: LocalDisplayTrack;
+  shareAudioTrack?: LocalSystemAudioTrack;
   videoDeviceId: any;
-  videoTrack: any;
+  videoTrack?: LocalCameraTrack;
   namespace = MEETINGS;
 
   /**
    * @param {Object} [options] -- to auto construct
    * @returns {MediaProperties}
    */
-  constructor(options: any = {}) {
+  constructor() {
     this.webrtcMediaConnection = null;
-    this.mediaDirection = options.mediaDirection;
-    this.videoTrack = options.videoTrack;
-    this.audioTrack = options.audioTrack;
-    this.shareTrack = options.shareTrack;
-    this.remoteShare = options.remoteShare;
-    this.remoteAudioTrack = options.remoteAudioTrack;
-    this.remoteVideoTrack = options.remoteVideoTrack;
-    this.localQualityLevel = options.localQualityLevel || QUALITY_LEVELS['720p'];
-    this.remoteQualityLevel = options.remoteQualityLevel || QUALITY_LEVELS.HIGH;
+    this.mediaDirection = {
+      receiveAudio: false,
+      receiveVideo: false,
+      receiveShare: false,
+      sendAudio: false,
+      sendVideo: false,
+      sendShare: false,
+    };
+    this.videoTrack = null;
+    this.audioTrack = null;
+    this.shareVideoTrack = null;
+    this.shareAudioTrack = null;
+    this.remoteShare = undefined;
+    this.remoteAudioTrack = undefined;
+    this.remoteVideoTrack = undefined;
+    this.remoteQualityLevel = QUALITY_LEVELS.HIGH;
     this.mediaSettings = {};
     this.videoDeviceId = null;
   }
@@ -60,20 +83,20 @@ export default class MediaProperties {
     this.webrtcMediaConnection = mediaPeerConnection;
   }
 
-  setLocalVideoTrack(videoTrack) {
+  setLocalVideoTrack(videoTrack?: LocalCameraTrack) {
     this.videoTrack = videoTrack;
   }
 
-  setLocalAudioTrack(audioTrack) {
+  setLocalAudioTrack(audioTrack?: LocalMicrophoneTrack) {
     this.audioTrack = audioTrack;
   }
 
-  setLocalQualityLevel(localQualityLevel) {
-    this.localQualityLevel = localQualityLevel;
+  setLocalShareVideoTrack(shareVideoTrack?: LocalDisplayTrack) {
+    this.shareVideoTrack = shareVideoTrack;
   }
 
-  setLocalShareTrack(shareTrack) {
-    this.shareTrack = shareTrack;
+  setLocalShareAudioTrack(shareAudioTrack?: LocalSystemAudioTrack) {
+    this.shareAudioTrack = shareAudioTrack;
   }
 
   setRemoteQualityLevel(remoteQualityLevel) {
@@ -115,31 +138,6 @@ export default class MediaProperties {
     this.webrtcMediaConnection = null;
   }
 
-  unsetLocalVideoTrack() {
-    this.videoTrack = null;
-  }
-
-  unsetLocalShareTrack() {
-    this.shareTrack = null;
-  }
-
-  unsetLocalAudioTrack() {
-    this.audioTrack = null;
-  }
-
-  /**
-   * Removes remote stream from class instance
-   * @deprecated after v1.89.3
-   * @returns {void}
-   */
-  unsetRemoteStream() {
-    LoggerProxy.logger.warn(
-      'Media:properties#unsetRemoteStream --> [DEPRECATION WARNING]: unsetRemoteStream has been deprecated after v1.89.3 (use unsetRemoteTracks instead)'
-    );
-    // unsets audio and video only
-    this.unsetRemoteMedia();
-  }
-
   /**
    * Removes both remote audio and video from class instance
    * @returns {void}
@@ -153,24 +151,6 @@ export default class MediaProperties {
     this.remoteShare = null;
   }
 
-  unsetLocalVideoTracks() {
-    this.unsetLocalVideoTrack();
-    this.unsetLocalShareTrack();
-  }
-
-  /**
-   * Removes remote stream and remote share from class instance
-   * @deprecated after v1.89.3
-   * @returns {void}
-   */
-  unsetRemoteStreams() {
-    LoggerProxy.logger.warn(
-      'Media:properties#unsetRemoteStreams --> [DEPRECATION WARNING]: unsetRemoteStreams has been deprecated after v1.89.3 (use unsetRemoteTracks instead)'
-    );
-    this.unsetRemoteStream();
-    this.unsetRemoteShare();
-  }
-
   /**
    * Unsets all remote tracks
    * @returns {void}
@@ -180,31 +160,12 @@ export default class MediaProperties {
     this.unsetRemoteShare();
   }
 
-  unsetShareStreams() {
-    this.unsetLocalShareTrack();
-    this.unsetRemoteShare();
-  }
-
   /**
-   * Removes both local and remote video stream from class instance
-   * @deprecated after v1.89.3
-   * @returns {void}
+   * Returns if we have at least one local share track or not.
+   * @returns {Boolean}
    */
-  unsetMediaStreams() {
-    LoggerProxy.logger.warn(
-      'Media:properties#unsetMediaStreams --> [DEPRECATION WARNING]: unsetMediaStreams has been deprecated after v1.89.3 (use unsetMediaTracks instead)'
-    );
-    this.unsetLocalVideoTrack();
-    this.unsetRemoteStream();
-  }
-
-  /**
-   * Removes both local and remote video stream from class instance
-   * @returns {void}
-   */
-  unsetMediaTracks() {
-    this.unsetLocalVideoTrack();
-    this.unsetRemoteMedia();
+  hasLocalShareTrack() {
+    return !!(this.shareAudioTrack || this.shareVideoTrack);
   }
 
   /**