@webex/plugin-meetings 3.0.0-beta.4 → 3.0.0-beta.400

package/src/media/properties.ts

@@ -0,0 +1,283 @@
+import {ConnectionState, Event} from '@webex/internal-media-core';
+
+import {
+  LocalCameraStream,
+  LocalMicrophoneStream,
+  LocalDisplayStream,
+  LocalSystemAudioStream,
+  RemoteStream,
+} from '@webex/media-helpers';
+
+import {MEETINGS, ICE_AND_DTLS_CONNECTION_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 {
+  audioStream?: LocalMicrophoneStream;
+  mediaDirection: MediaDirection;
+  mediaSettings: any;
+  webrtcMediaConnection: any;
+  remoteAudioStream: RemoteStream;
+  remoteQualityLevel: any;
+  remoteShareStream: RemoteStream;
+  remoteVideoStream: RemoteStream;
+  shareVideoStream?: LocalDisplayStream;
+  shareAudioStream?: LocalSystemAudioStream;
+  videoDeviceId: any;
+  videoStream?: LocalCameraStream;
+  namespace = MEETINGS;
+
+  /**
+   * @param {Object} [options] -- to auto construct
+   * @returns {MediaProperties}
+   */
+  constructor() {
+    this.webrtcMediaConnection = null;
+    this.mediaDirection = {
+      receiveAudio: false,
+      receiveVideo: false,
+      receiveShare: false,
+      sendAudio: false,
+      sendVideo: false,
+      sendShare: false,
+    };
+    this.videoStream = null;
+    this.audioStream = null;
+    this.shareVideoStream = null;
+    this.shareAudioStream = null;
+    this.remoteShareStream = undefined;
+    this.remoteAudioStream = undefined;
+    this.remoteVideoStream = undefined;
+    this.remoteQualityLevel = QUALITY_LEVELS.HIGH;
+    this.mediaSettings = {};
+    this.videoDeviceId = null;
+  }
+
+  /**
+   * Retrieves the preferred video input device
+   * @returns {Object|null}
+   */
+  getVideoDeviceId() {
+    return this.videoDeviceId || null;
+  }
+
+  setMediaDirection(mediaDirection) {
+    this.mediaDirection = mediaDirection;
+  }
+
+  setMediaSettings(type, values) {
+    this.mediaSettings[type] = values;
+  }
+
+  setMediaPeerConnection(mediaPeerConnection) {
+    this.webrtcMediaConnection = mediaPeerConnection;
+  }
+
+  setLocalVideoStream(videoStream?: LocalCameraStream) {
+    this.videoStream = videoStream;
+  }
+
+  setLocalAudioStream(audioStream?: LocalMicrophoneStream) {
+    this.audioStream = audioStream;
+  }
+
+  setLocalShareVideoStream(shareVideoStream?: LocalDisplayStream) {
+    this.shareVideoStream = shareVideoStream;
+  }
+
+  setLocalShareAudioStream(shareAudioStream?: LocalSystemAudioStream) {
+    this.shareAudioStream = shareAudioStream;
+  }
+
+  setRemoteQualityLevel(remoteQualityLevel) {
+    this.remoteQualityLevel = remoteQualityLevel;
+  }
+
+  setRemoteShareStream(remoteShareStream: RemoteStream) {
+    this.remoteShareStream = remoteShareStream;
+  }
+
+  /**
+   * Sets the remote audio stream
+   * @param {RemoteStream} remoteAudioStream RemoteStream to save
+   * @returns {void}
+   */
+  setRemoteAudioStream(remoteAudioStream: RemoteStream) {
+    this.remoteAudioStream = remoteAudioStream;
+  }
+
+  /**
+   * Sets the remote video stream
+   * @param {RemoteStream} remoteVideoStream RemoteStream to save
+   * @returns {void}
+   */
+  setRemoteVideoStream(remoteVideoStream: RemoteStream) {
+    this.remoteVideoStream = remoteVideoStream;
+  }
+
+  /**
+   * Stores the preferred video input device
+   * @param {string} deviceId Preferred video input device
+   * @returns {void}
+   */
+  setVideoDeviceId(deviceId: string) {
+    this.videoDeviceId = deviceId;
+  }
+
+  unsetPeerConnection() {
+    this.webrtcMediaConnection = null;
+  }
+
+  /**
+   * Removes both remote audio and video from class instance
+   * @returns {void}
+   */
+  unsetRemoteMedia() {
+    this.remoteAudioStream = null;
+    this.remoteVideoStream = null;
+  }
+
+  unsetRemoteShareStream() {
+    this.remoteShareStream = null;
+  }
+
+  /**
+   * Unsets all remote streams
+   * @returns {void}
+   */
+  unsetRemoteStreams() {
+    this.unsetRemoteMedia();
+    this.unsetRemoteShareStream();
+  }
+
+  /**
+   * Returns if we have at least one local share stream or not.
+   * @returns {Boolean}
+   */
+  hasLocalShareStream() {
+    return !!(this.shareAudioStream || this.shareVideoStream);
+  }
+
+  /**
+   * Waits for the webrtc media connection to be connected.
+   *
+   * @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);
+    });
+  }
+
+  /**
+   * Returns the type of a connection that has been established
+   *
+   * @returns {Promise<'UDP' | 'TCP' | 'TURN-TLS' | 'TURN-TCP' | 'TURN-UDP' | 'unknown'>}
+   */
+  async getCurrentConnectionType() {
+    // we can only get the connection type after ICE connection has been established
+    await this.waitForMediaConnectionConnected();
+
+    const allStatsReports = [];
+
+    try {
+      const statsResult = await this.webrtcMediaConnection.getStats();
+      statsResult.forEach((report) => allStatsReports.push(report));
+    } catch (error) {
+      LoggerProxy.logger.warn(
+        `Media:properties#getCurrentConnectionType --> getStats() failed: ${error}`
+      );
+    }
+
+    const successfulCandidatePairs = allStatsReports.filter(
+      (report) => report.type === 'candidate-pair' && report.state?.toLowerCase() === 'succeeded'
+    );
+
+    let foundConnectionType = 'unknown';
+
+    // all of the successful pairs should have the same connection type, so just return the type for the first one
+    successfulCandidatePairs.some((pair) => {
+      const localCandidate = allStatsReports.find(
+        (report) => report.type === 'local-candidate' && report.id === pair.localCandidateId
+      );
+
+      if (localCandidate === undefined) {
+        LoggerProxy.logger.warn(
+          `Media:properties#getCurrentConnectionType --> failed to find local candidate "${pair.localCandidateId}" in getStats() results`
+        );
+
+        return false;
+      }
+
+      let connectionType;
+
+      if (localCandidate.relayProtocol) {
+        connectionType = `TURN-${localCandidate.relayProtocol.toUpperCase()}`;
+      } else {
+        connectionType = localCandidate.protocol?.toUpperCase(); // it will be UDP or TCP
+      }
+
+      if (connectionType) {
+        foundConnectionType = connectionType;
+
+        return true;
+      }
+      LoggerProxy.logger.warn(
+        `Media:properties#getCurrentConnectionType --> missing localCandidate.protocol, candidateType=${localCandidate.candidateType}`
+      );
+
+      return false;
+    });
+
+    if (foundConnectionType === 'unknown') {
+      const candidatePairStates = allStatsReports
+        .filter((report) => report.type === 'candidate-pair')
+        .map((report) => report.state);
+
+      LoggerProxy.logger.warn(
+        `Media:properties#getCurrentConnectionType --> all candidate pair states: ${JSON.stringify(
+          candidatePairStates
+        )}`
+      );
+    }
+
+    return foundConnectionType;
+  }
+}

package/src/media/{util.js → util.ts}

@@ -2,11 +2,11 @@
 
 import LoggerProxy from '../common/logs/logger-proxy';
 
-const MediaUtil = {};
+const MediaUtil: any = {};
 
 MediaUtil.createMediaStream = (tracks) => {
   if (!tracks) {
-    LoggerProxy.logger.error('Media:util#createMediaStream --> Tracks don\'t exist');
+    LoggerProxy.logger.error("Media:util#createMediaStream --> Tracks don't exist");
   }
   const filtredTracks = tracks.filter((element) => !!element);
 

package/src/mediaQualityMetrics/config.ts

@@ -0,0 +1,249 @@
+export const emptyMqaInterval = {
+  audioReceive: [],
+  audioTransmit: [],
+  intervalMetadata: {
+    peerReflexiveIP: '0.0.0.0',
+    peripherals: [],
+    processAverageCPU: 0,
+    processMaximumCPU: 0,
+    systemAverageCPU: 0,
+    systemMaximumCPU: 0,
+  },
+  networkType: '',
+  intervalNumber: 0,
+  videoReceive: [],
+  videoTransmit: [],
+};
+
+export const emptyAudioReceive = {
+  common: {
+    common: {
+      direction: 'inactive',
+      isMain: true,
+      mariFecEnabled: false,
+      mariQosEnabled: false,
+      multistreamEnabled: false,
+    },
+    dtlsBitrate: 0,
+    dtlsPackets: 0,
+    fecBitrate: 0,
+    fecPackets: 0,
+    maxBitrate: 0,
+    mediaHopByHopLost: 0,
+    rtcpBitrate: 0,
+    rtcpPackets: 0,
+    rtpBitrate: 0,
+    rtpHopByHopLost: 0,
+    rtpPackets: 0,
+    rtpRecovered: 0,
+    rtxBitrate: 0,
+    rtxPackets: 0,
+    srtcpUnprotectErrors: 0,
+    srtpUnprotectErrors: 0,
+    stunBitrate: 0,
+    stunPackets: 0,
+    transportType: 'UDP',
+  },
+  streams: [],
+};
+
+export const emptyAudioReceiveStream = {
+  common: {
+    codec: 'opus',
+    concealedFrames: 0,
+    csi: [],
+    maxConcealRunLength: 0,
+    optimalBitrate: 0,
+    optimalFrameRate: 0,
+    receivedBitrate: 0,
+    receivedFrameRate: 0,
+    renderedFrameRate: 0,
+    requestedBitrate: 0,
+    requestedFrameRate: 0,
+    rtpEndToEndLost: 0,
+    maxRtpJitter: 0,
+    meanRtpJitter: 0,
+    rtpPackets: 0,
+    ssci: 0,
+  },
+};
+
+export const emptyAudioTransmit = {
+  common: {
+    availableBitrate: 0,
+    common: {
+      direction: 'inactive',
+      isMain: true,
+      mariFecEnabled: false,
+      mariQosEnabled: false,
+      multistreamEnabled: false,
+    },
+    dtlsBitrate: 0,
+    dtlsPackets: 0,
+    fecBitrate: 0,
+    fecPackets: 0,
+    maxBitrate: 0,
+    queueDelay: 0,
+    remoteJitter: 0,
+    remoteLossRate: 0,
+    remoteReceiveRate: 0,
+    roundTripTime: 0,
+    rtcpBitrate: 0,
+    rtcpPackets: 0,
+    rtpBitrate: 0,
+    rtpPackets: 0,
+    rtxBitrate: 0,
+    rtxPackets: 0,
+    stunBitrate: 0,
+    stunPackets: 0,
+    transportType: 'UDP',
+  },
+  streams: [],
+};
+
+export const emptyAudioTransmitStream = {
+  common: {
+    codec: 'opus',
+    csi: [],
+    requestedBitrate: 0,
+    requestedFrames: 0,
+    rtpPackets: 0,
+    ssci: 0,
+    transmittedBitrate: 0,
+    transmittedFrameRate: 0,
+  },
+};
+
+export const emptyVideoReceive = {
+  common: {
+    common: {
+      direction: 'inactive',
+      isMain: true, // Not avaliable
+      mariFecEnabled: true, // Not avaliable
+      mariQosEnabled: true, // Not avaliable
+      multistreamEnabled: true, // Not avaliable
+    },
+    dtlsBitrate: 0, // Not avaliable
+    dtlsPackets: 0, // Not avaliable
+    fecBitrate: 0, // Not avaliable
+    fecPackets: 0, // Not avaliable
+    maxBitrate: 0,
+    mediaHopByHopLost: 0,
+    rtcpBitrate: 0, // Not avaliable
+    rtcpPackets: 0, // Not avaliable
+    rtpBitrate: 0,
+    rtpHopByHopLost: 0,
+    rtpPackets: 0,
+    rtpRecovered: 0, // Not avaliable
+    rtxBitrate: 0, // Not avaliable
+    rtxPackets: 0, // Not avaliable
+    srtcpUnprotectErrors: 0, // Not avaliable
+    srtpUnprotectErrors: 0, // Not avaliable
+    stunBitrate: 0, // Not avaliable
+    stunPackets: 0, // Not avaliable
+    transportType: 'UDP',
+  },
+  streams: [],
+};
+
+export const emptyVideoReceiveStream = {
+  common: {
+    codec: 'H264',
+    concealedFrames: 0, // Not avaliable
+    csi: [],
+    maxConcealRunLength: 0, // Not avaliable
+    optimalBitrate: 0,
+    optimalFrameRate: 0,
+    receivedBitrate: 0,
+    receivedFrameRate: 0,
+    renderedFrameRate: 0, // Not avaliable
+    requestedBitrate: 0,
+    requestedFrameRate: 0,
+    rtpEndToEndLost: 0,
+    rtpJitter: 0,
+    rtpPackets: 0,
+    ssci: 0, // Not avaliable
+  },
+  h264CodecProfile: 'BP',
+  isActiveSpeaker: true,
+  optimalFrameSize: 0, // Not avaliable
+  receivedFrameSize: 0,
+  receivedHeight: 0,
+  receivedKeyFrames: 0,
+  receivedKeyFramesForRequest: 0,
+  receivedKeyFramesSourceChange: 0,
+  receivedKeyFramesUnknown: 0,
+  receivedWidth: 0,
+  requestedFrameSize: 0,
+  requestedKeyFrames: 0,
+};
+
+export const emptyVideoTransmit = {
+  common: {
+    availableBitrate: 0, // Not avaliable currently hardcoded
+    common: {
+      direction: 'inactive',
+      isMain: true,
+      mariFecEnabled: false, // Not avaliable
+      mariQosEnabled: false, // Not avaliable
+      multistreamEnabled: false, // Not avaliable
+    },
+    dtlsBitrate: 0, // Not avaliable
+    dtlsPackets: 0, // Not avaliable
+    fecBitrate: 0, // Not avaliable
+    fecPackets: 0, // TODO: check inbound-rtp// Not avaliable
+    maxBitrate: 0, // Currently hardcoded
+    queueDelay: 0, // outboundRtp.totalPacketSentDelay  // TODO: check if totalInterFrameDelay/ packetSentDelay/ jitterBufferDalay
+    remoteJitter: 0, // remoteInboundRtp.jitter
+    remoteLossRate: 0, // comparedResults.lossRate
+    remoteReceiveRate: 0, // compareResults.packetsLost
+    roundTripTime: 0, // compareResults.roundTripTime
+    rtcpBitrate: 0, // Dont have access to it
+    rtcpPackets: 0, // Dont have access to rtcp
+    rtpBitrate: 0, // Dont have access
+    rtpPackets: 0, // outboundRtp.packetsSent
+    rtxBitrate: 0, // Dont have access to it
+    rtxPackets: 0, // Dont have access to it
+    stunBitrate: 0, // Dont have access to it
+    stunPackets: 0, // Dont have access to it
+    transportType: 'UDP', // TODO: need to calculate
+  },
+  streams: [],
+};
+
+export const emptyVideoTransmitStream = {
+  common: {
+    codec: 'H264',
+    csi: [],
+    duplicateSsci: 0, // Not Avaliable
+    requestedBitrate: 0, // TODO: from remote SDP
+    requestedFrames: 0, // TODO: from remote SDP
+    rtpPackets: 0, // same as rtp packets
+    ssci: 0,
+    transmittedBitrate: 0, // TODO: get in the candidate pair
+    transmittedFrameRate: 0, // TODO: from track info
+  },
+  h264CodecProfile: 'BP', // TODO: from localSDP
+  isAvatar: false, // Not Avaliable
+  isHardwareEncoded: false, // Not Avaliable
+  localConfigurationChanges: 2, // Not Avaliable
+  maxFrameQp: 0, // Not Avaliable
+  maxNoiseLevel: 0, // Not Avaliable
+  minRegionQp: 0, // Not Avaliable
+  remoteConfigurationChanges: 0, // Not Avaliable
+  requestedFrameSize: 0, // TODO: from remote SDP
+  requestedKeyFrames: 0, // outbound Fir request
+  transmittedFrameSize: 0, // Not Avaliable
+  transmittedHeight: 0,
+  transmittedKeyFrames: 0, // Key frames encoded
+  transmittedKeyFramesClient: 0, // Not Avaliable
+  transmittedKeyFramesConfigurationChange: 0, // Not Avaliable
+  transmittedKeyFramesFeedback: 0, // Not Avaliable
+  transmittedKeyFramesLocalDrop: 0, // Not Avaliable
+  transmittedKeyFramesOtherLayer: 0, // Not Avaliable
+  transmittedKeyFramesPeriodic: 0, // Not Avaliable
+  transmittedKeyFramesSceneChange: 0, // Not Avaliable
+  transmittedKeyFramesStartup: 0, // Not Avaliable
+  transmittedKeyFramesUnknown: 0, // Not Avaliable
+  transmittedWidth: 0,
+};