@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

package/src/media/index.ts

@@ -3,29 +3,21 @@
  */
 /* globals navigator */
 
-import {
-  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 {
+  AUDIO_INPUT,
+  VIDEO_INPUT,
+  PEER_CONNECTION_STATE,
+  MEDIA_TRACK_CONSTRAINT,
+} from '../constants';
 import Config from '../config';
-import StaticConfig from '../common/config';
+import PeerConnectionManager from '../peer-connection-manager';
+import ReconnectionError from '../common/errors/reconnection';
+import MediaError from '../common/errors/media';
 import BrowserDetection from '../common/browser-detection';
-import RtcMetrics from '../rtcMetrics';
 
 const {isBrowser} = BrowserDetection();
 
-export type BundlePolicy = MultistreamConnectionConfig['bundlePolicy'];
-
 /**
  * MediaDirection
  * @typedef {Object} MediaDirection
@@ -56,6 +48,81 @@ export type BundlePolicy = MultistreamConnectionConfig['bundlePolicy'];
  */
 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
@@ -82,159 +149,230 @@ 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 (forceSendRecv || (receive && send)) {
-    return 'sendrecv';
-  }
+  };
 
-  if (receive) {
-    return 'recvonly';
+  if (track) {
+    return {track, direction: getDirection(!!track, receiveTracks)};
   }
 
-  return 'sendonly';
+  return {track: trackType, direction: getDirection(!!track, receiveTracks)};
 };
-
 /**
- * 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}
+ * 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.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;
+Media.attachMedia = (
+  mediaProperties: any,
+  {
+    meetingId,
+    remoteQualityLevel,
+    enableRtx,
+    enableExtmap,
+  }: {
+    meetingId: string;
+    remoteQualityLevel: string;
+    enableRtx: any;
+    enableExtmap: any;
   }
 ) => {
-  const {
-    mediaProperties,
+  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}`
+    );
+  };
+
+  return PeerConnectionManager.createOffer(peerConnection, {
+    meetingId,
     remoteQualityLevel,
     enableRtx,
     enableExtmap,
-    turnServerInfo,
-    bundlePolicy,
-  } = options;
-
-  const iceServers = [];
+  });
+};
 
-  if (turnServerInfo) {
-    iceServers.push({
-      urls: turnServerInfo.url,
-      username: turnServerInfo.username || '',
-      credential: turnServerInfo.password || '',
-    });
+/**
+ * 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}
+ */
+Media.updateMedia = (
+  mediaProperties: any,
+  {
+    meetingId,
+    remoteQualityLevel,
+    enableRtx,
+    enableExtmap,
+  }: {
+    meetingId: string;
+    remoteQualityLevel: string;
+    enableRtx: any;
+    enableExtmap: any;
   }
+) => {
+  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,
+  });
 
-  if (isMultistream) {
-    const config: MultistreamConnectionConfig = {
-      iceServers,
-    };
+  // update video transceiver
+  Media.setTrackOnTransceiver(peerConnection.videoTransceiver, {
+    type: 'video',
+    track: videoTrack,
+    sendTrack: mediaDirection.sendVideo && videoTrack,
+    receiveTrack: mediaDirection.receiveVideo,
+  });
 
-    if (bundlePolicy) {
-      config.bundlePolicy = bundlePolicy;
-    }
+  // 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}`
+    );
+  };
 
-    const rtcMetrics = new RtcMetrics(webex, meetingId, correlationId);
+  return PeerConnectionManager.createOffer(peerConnection, {
+    meetingId,
+    remoteQualityLevel,
+    enableRtx,
+    enableExtmap,
+  });
+};
 
-    return new MultistreamRoapMediaConnection(
-      config,
-      meetingId,
-      /* the rtc metrics objects callbacks */
-      (data) => rtcMetrics.addMetrics(data),
-      () => rtcMetrics.closeMetrics(),
-      () => rtcMetrics.sendMetricsInQueue()
-    );
+/**
+ * @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 {type, track, sendTrack, receiveTrack} = options;
+
+  try {
+    const result = Media.checkTracks(type, sendTrack && track, receiveTrack);
 
-  if (!mediaProperties) {
-    throw new Error('mediaProperties have to be provided for non-multistream media connections');
+    transceiver.direction = result.direction;
+    if (options.track) {
+      transceiver.sender.replaceTrack(track);
+    }
+  } catch (e) {
+    LoggerProxy.logger.error(`Media:index#setTrackOnTransceiver --> ${e}`);
+    throw e;
   }
+};
 
-  const {mediaDirection, audioStream, videoStream, shareVideoStream, shareAudioStream} =
-    mediaProperties;
+/**
+ * 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);
 
-  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
-  );
+  return PeerConnectionManager.createOffer(peerConnection, {
+    meetingId,
+    remoteQualityLevel,
+    enableRtx,
+    enableExtmap,
+  });
 };
 
 /**
@@ -376,6 +514,52 @@ 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
@@ -386,21 +570,54 @@ Media.toggleStream = () => {};
 
 /**
  * Stop input stream
- * @param {LocalStream} stream A local stream
+ * @param {MediaTrack} track A media stream
  * @returns {null}
  */
-Media.stopStream = (stream: LocalStream) => {
+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'
+  );
   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(() => {
-    try {
+    if (stream.getTracks) {
+      stream.getTracks().forEach((track) => {
+        track.stop();
+      });
+    } else if (stream.stop) {
       stream.stop();
-    } catch (e) {
-      LoggerProxy.logger.error(
-        `Media:index#stopStream --> Unable to stop the stream with ready state => ${stream.readyState}, error: ${e}`
-      );
     }
   });
 };