@webex/plugin-meetings 2.60.0 → 2.60.1-next.10

package/src/media/index.ts

@@ -3,21 +3,29 @@
  */
 /* globals navigator */
 
-import LoggerProxy from '../common/logs/logger-proxy';
 import {
-  AUDIO_INPUT,
-  VIDEO_INPUT,
-  PEER_CONNECTION_STATE,
-  MEDIA_TRACK_CONSTRAINT,
-} from '../constants';
+  RoapMediaConnection,
+  MultistreamRoapMediaConnection,
+  type MultistreamConnectionConfig,
+} from '@webex/internal-media-core';
+import {
+  LocalStream,
+  LocalCameraStream,
+  LocalDisplayStream,
+  LocalSystemAudioStream,
+  LocalMicrophoneStream,
+} from '@webex/media-helpers';
+import LoggerProxy from '../common/logs/logger-proxy';
+import {MEDIA_TRACK_CONSTRAINT} from '../constants';
 import Config from '../config';
-import PeerConnectionManager from '../peer-connection-manager';
-import ReconnectionError from '../common/errors/reconnection';
-import MediaError from '../common/errors/media';
+import StaticConfig from '../common/config';
 import BrowserDetection from '../common/browser-detection';
+import RtcMetrics from '../rtcMetrics';
 
 const {isBrowser} = BrowserDetection();
 
+export type BundlePolicy = MultistreamConnectionConfig['bundlePolicy'];
+
 /**
  * MediaDirection
  * @typedef {Object} MediaDirection
@@ -48,81 +56,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;
-};
-
-/**
- * @param {RTCPeerConnection} peerConnection
- * @param {Object} meetingProperties
- * @param {string} meetingProperties.meetingId
- * @param {string} meetingProperties.remoteQualityLevel LOW|MEDIUM|HIGH
- * @returns {Promise}
- */
-Media.reconnectMedia = (
-  peerConnection: RTCPeerConnection,
-  {
-    meetingId,
-    remoteQualityLevel,
-    enableRtx,
-    enableExtmap,
-  }: {
-    meetingId: string;
-    remoteQualityLevel: string;
-    enableRtx: any;
-    enableExtmap: any;
-  }
-) => {
-  if (
-    peerConnection.connectionState === PEER_CONNECTION_STATE.CLOSED ||
-    peerConnection.connectionState === PEER_CONNECTION_STATE.FAILED
-  ) {
-    return Promise.reject(new ReconnectionError('Reinitiate peerconnection'));
-  }
-
-  return PeerConnectionManager.createOffer(peerConnection, {
-    meetingId,
-    remoteQualityLevel,
-    enableRtx,
-    enableExtmap,
-  });
-};
-
-/**
- * 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
@@ -149,230 +82,159 @@ Media.getLocalMedia = (options: any, config: object) => {
 
   return Promise.resolve(undefined);
 };
-/**
- * Returns the direction and tracks
- * @param {string} trackType type of track (audio/video)
- * @param {object}  track  tracks passed
- * @param {boolean} receiveTracks do you want to receive tracks from the remote side
- * @returns {Object} returns direction tracks to be added in transceiver
- */
-Media.checkTracks = (trackType: string, track: object, receiveTracks: boolean) => {
-  // eslint-disable-next-line @typescript-eslint/no-shadow
-  const getDirection = (sendTracks, receiveTracks) => {
-    if (sendTracks && receiveTracks) {
-      return 'sendrecv';
-    }
-    if (sendTracks && !receiveTracks) {
-      return 'sendonly';
-    }
-    if (!sendTracks && receiveTracks) {
-      return 'recvonly';
-    }
 
+Media.getDirection = (forceSendRecv: boolean, receive: boolean, send: boolean) => {
+  if (!receive && !send) {
     return 'inactive';
-  };
-
-  if (track) {
-    return {track, direction: getDirection(!!track, receiveTracks)};
   }
 
-  return {track: trackType, direction: getDirection(!!track, receiveTracks)};
-};
-/**
- * creates peerconnection and attaches streams
- * @param {MediaDirection} mediaProperties
- * @param {Object} meetingProperties
- * @param {string} meetingProperties.meetingId
- * @param {string} meetingProperties.remoteQualityLevel LOW|MEDIUM|HIGH
- * @returns {Array} [peerConnection, ]
- */
-Media.attachMedia = (
-  mediaProperties: any,
-  {
-    meetingId,
-    remoteQualityLevel,
-    enableRtx,
-    enableExtmap,
-  }: {
-    meetingId: string;
-    remoteQualityLevel: string;
-    enableRtx: any;
-    enableExtmap: any;
+  if (forceSendRecv || (receive && send)) {
+    return 'sendrecv';
   }
-) => {
-  const {mediaDirection, audioTrack, videoTrack, shareTrack, peerConnection} = mediaProperties;
-
-  let result = null;
-
-  // Add Transceiver for audio
-  result = Media.checkTracks(
-    'audio',
-    mediaDirection.sendAudio && audioTrack,
-    mediaDirection.receiveAudio
-  );
-  peerConnection.audioTransceiver = peerConnection.addTransceiver(result.track, {
-    direction: result.direction,
-  });
-
-  // Add Transceiver for video
-  result = Media.checkTracks(
-    'video',
-    mediaDirection.sendVideo && videoTrack,
-    mediaDirection.receiveVideo
-  );
-  peerConnection.videoTransceiver = peerConnection.addTransceiver(result.track, {
-    direction: result.direction,
-  });
-
-  // Add Transceiver for share
-  result = Media.checkTracks(
-    'video',
-    mediaDirection.sendShare && shareTrack,
-    mediaDirection.receiveShare
-  );
-  peerConnection.shareTransceiver = peerConnection.addTransceiver(result.track, {
-    direction: result.direction,
-  });
 
-  peerConnection.onnegotiationneeded = (event) => {
-    LoggerProxy.logger.info(
-      `Media:index#attachMedia --> onnegotiationneeded#PeerConnection: ${event}`
-    );
-  };
+  if (receive) {
+    return 'recvonly';
+  }
 
-  return PeerConnectionManager.createOffer(peerConnection, {
-    meetingId,
-    remoteQualityLevel,
-    enableRtx,
-    enableExtmap,
-  });
+  return 'sendonly';
 };
 
 /**
- * updates all the media streams and creates a new media offer
- * @param {MediaDirection} mediaProperties
- * @param {Object} meetingProperties
- * @param {string} meetingProperties.meetingId
- * @param {string} meetingProperties.remoteQualityLevel LOW|MEDIUM|HIGH
- * @returns {Promise}
+ * 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] 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]
+ * @param {BundlePolicy} [options.bundlePolicy]
+ * @returns {RoapMediaConnection | MultistreamRoapMediaConnection}
  */
-Media.updateMedia = (
-  mediaProperties: any,
-  {
-    meetingId,
-    remoteQualityLevel,
-    enableRtx,
-    enableExtmap,
-  }: {
-    meetingId: string;
-    remoteQualityLevel: string;
-    enableRtx: any;
-    enableExtmap: any;
+Media.createMediaConnection = (
+  isMultistream: boolean,
+  debugId: string,
+  webex: object,
+  meetingId: string,
+  correlationId: string,
+  options: {
+    mediaProperties: {
+      mediaDirection?: {
+        receiveAudio: boolean;
+        receiveVideo: boolean;
+        receiveShare: boolean;
+        sendAudio: boolean;
+        sendVideo: boolean;
+        sendShare: boolean;
+      };
+      audioStream?: LocalMicrophoneStream;
+      videoStream?: LocalCameraStream;
+      shareVideoStream?: LocalDisplayStream;
+      shareAudioStream?: LocalSystemAudioStream;
+    };
+    remoteQualityLevel?: 'LOW' | 'MEDIUM' | 'HIGH';
+    enableRtx?: boolean;
+    enableExtmap?: boolean;
+    turnServerInfo?: {
+      url: string;
+      username: string;
+      password: string;
+    };
+    bundlePolicy?: BundlePolicy;
   }
 ) => {
-  const {mediaDirection, audioTrack, videoTrack, shareTrack, peerConnection} = mediaProperties;
-
-  // update audio transceiver
-  Media.setTrackOnTransceiver(peerConnection.audioTransceiver, {
-    type: 'audio',
-    track: audioTrack,
-    sendTrack: mediaDirection.sendAudio && audioTrack,
-    receiveTrack: mediaDirection.receiveAudio,
-  });
-
-  // update video transceiver
-  Media.setTrackOnTransceiver(peerConnection.videoTransceiver, {
-    type: 'video',
-    track: videoTrack,
-    sendTrack: mediaDirection.sendVideo && videoTrack,
-    receiveTrack: mediaDirection.receiveVideo,
-  });
-
-  // update content transceiver
-  Media.setTrackOnTransceiver(peerConnection.shareTransceiver, {
-    type: 'video',
-    track: shareTrack,
-    sendTrack: mediaDirection.sendShare && shareTrack,
-    receiveTrack: mediaDirection.receiveShare,
-  });
-  peerConnection.onnegotiationneeded = (event) => {
-    LoggerProxy.logger.info(
-      `Media:index#updateMedia --> onnegotiationneeded#PeerConnection: ${event}`
-    );
-  };
-
-  return PeerConnectionManager.createOffer(peerConnection, {
-    meetingId,
+  const {
+    mediaProperties,
     remoteQualityLevel,
     enableRtx,
     enableExtmap,
-  });
-};
+    turnServerInfo,
+    bundlePolicy,
+  } = options;
 
-/**
- * @param {RTCRtpTransceiver} transceiver
- * @param {Object} options
- * @param {MediaStreamTrack} options.track
- * @returns {undefined}
- */
-Media.setTrackOnTransceiver = (
-  transceiver: RTCRtpTransceiver,
-  options: {
-    track: MediaStreamTrack;
-    type: any;
-    sendTrack: any;
-    receiveTrack: any;
+  const iceServers = [];
+
+  if (turnServerInfo) {
+    iceServers.push({
+      urls: turnServerInfo.url,
+      username: turnServerInfo.username || '',
+      credential: turnServerInfo.password || '',
+    });
   }
-) => {
-  const {type, track, sendTrack, receiveTrack} = options;
 
-  try {
-    const result = Media.checkTracks(type, sendTrack && track, receiveTrack);
+  if (isMultistream) {
+    const config: MultistreamConnectionConfig = {
+      iceServers,
+    };
 
-    transceiver.direction = result.direction;
-    if (options.track) {
-      transceiver.sender.replaceTrack(track);
+    if (bundlePolicy) {
+      config.bundlePolicy = bundlePolicy;
     }
-  } catch (e) {
-    LoggerProxy.logger.error(`Media:index#setTrackOnTransceiver --> ${e}`);
-    throw e;
+
+    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()
+    );
   }
-};
 
-/**
- * creates a new offer
- * @param {Object} meetingProperties
- * @param {string} meetingProperties.meetingId
- * @param {string} meetingProperties.remoteQualityLevel LOW|MEDIUM|HIGH
- * @param {RTCPeerConnection} peerConnection
- * @param {RTCRtpTransceiver} transceiver
- * @param {Object} options see #Media.setTrackOnTransceiver
- * @returns {Promise}
- */
-Media.updateTransceiver = (
-  {
-    meetingId,
-    remoteQualityLevel,
-    enableRtx,
-    enableExtmap,
-  }: {
-    meetingId: string;
-    remoteQualityLevel: string;
-    enableRtx: any;
-    enableExtmap: any;
-  },
-  peerConnection: RTCPeerConnection,
-  transceiver: RTCRtpTransceiver,
-  options: object
-) => {
-  Media.setTrackOnTransceiver(transceiver, options);
+  if (!mediaProperties) {
+    throw new Error('mediaProperties have to be provided for non-multistream media connections');
+  }
 
-  return PeerConnectionManager.createOffer(peerConnection, {
-    meetingId,
-    remoteQualityLevel,
-    enableRtx,
-    enableExtmap,
-  });
+  const {mediaDirection, audioStream, videoStream, shareVideoStream, shareAudioStream} =
+    mediaProperties;
+
+  return new RoapMediaConnection(
+    {
+      iceServers,
+      skipInactiveTransceivers: false,
+      requireH264: true,
+      sdpMunging: {
+        convertPort9to0: false,
+        addContentSlides: true,
+        bandwidthLimits: {
+          audio: StaticConfig.meetings.bandwidth.audio,
+          video: StaticConfig.meetings.bandwidth.video,
+        },
+        startBitrate: StaticConfig.meetings.bandwidth.startBitrate,
+        periodicKeyframes: 20, // it's always been hardcoded in SDK so for now keeping it that way
+        disableExtmap: !enableExtmap,
+        disableRtx: !enableRtx, // see https://bugs.chromium.org/p/chromium/issues/detail?id=1020642 why we might want to remove RTX from SDP
+      },
+    },
+    {
+      // TODO: RoapMediaConnection is not ready to use stream classes yet, so we pass the raw MediaStreamTrack for now SPARK-460530
+      localTracks: {
+        audio: audioStream?.outputStream?.getTracks()[0],
+        video: videoStream?.outputStream?.getTracks()[0],
+        screenShareVideo: shareVideoStream?.outputStream?.getTracks()[0],
+        screenShareAudio: shareAudioStream?.outputStream?.getTracks()[0], // TODO: add type for screenShareAudio in internal-media-core SPARK-446923
+      } as unknown,
+      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
+  );
 };
 
 /**
@@ -514,52 +376,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
@@ -570,54 +386,21 @@ Media.toggleStream = () => {};
 
 /**
  * Stop input stream
- * @param {MediaTrack} track A media stream
+ * @param {LocalStream} stream A local stream
  * @returns {null}
  */
-Media.stopTracks = (track: any) => {
-  if (!track) {
-    return Promise.resolve();
-  }
-
-  return Promise.resolve().then(() => {
-    if (track && track.stop) {
-      try {
-        track.stop();
-      } catch (e) {
-        LoggerProxy.logger.error(
-          `Media:index#stopTracks --> Unable to stop the track with state ${track.readyState}, error: ${e}`
-        );
-      }
-    }
-  });
-};
-
-/**
- *
- * Stop input stream
- * @param {Stream} stream A media stream
- * @returns {null}
- * @deprecated after v1.89.3
- */
-Media.stopStream = (stream: any) => {
-  LoggerProxy.logger.warn(
-    'Media:index#stopStream --> [DEPRECATION WARNING]: stopStream has been deprecated after v1.89.3'
-  );
+Media.stopStream = (stream: LocalStream) => {
   if (!stream) {
     return Promise.resolve();
   }
 
-  /*
-   * To release local media
-   * 1) Chrome requires all tracks to be stopped (stream.stop got deprecated)
-   * 2) Firefox requires the stream to be stopped
-   */
   return Promise.resolve().then(() => {
-    if (stream.getTracks) {
-      stream.getTracks().forEach((track) => {
-        track.stop();
-      });
-    } else if (stream.stop) {
+    try {
       stream.stop();
+    } catch (e) {
+      LoggerProxy.logger.error(
+        `Media:index#stopStream --> Unable to stop the stream with ready state => ${stream.readyState}, error: ${e}`
+      );
     }
   });
 };