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

package/src/multistream/multistreamMedia.ts

@@ -1,92 +0,0 @@
-/* eslint-disable import/prefer-default-export */
-
-import {AUDIO, VIDEO} from '../constants';
-import createMuteState from '../meeting/muteState';
-import Meeting from '../meeting';
-
-/**
- * Class wrapping all the multistream specific APIs that need to be exposed at meeting level.
- *
- */
-export class MultistreamMedia {
-  private meeting: Meeting;
-
-  /**
-   * Constructor
-   * @param {Meeting} meeting
-   */
-  constructor(meeting: Meeting) {
-    this.meeting = meeting;
-  }
-
-  /**
-   * throws if we don't have a media connection created
-   */
-  private checkMediaConnection() {
-    if (this.meeting?.mediaProperties?.webrtcMediaConnection) {
-      return;
-    }
-    throw new Error('Webrtc media connection is missing');
-  }
-
-  /**
-   * Publishes a local track in the meeting
-   *
-   * @param {MediaStreamTrack} track
-   * @returns {Promise}
-   */
-  publishTrack(track: MediaStreamTrack): Promise<void> {
-    this.checkMediaConnection();
-
-    /* todo: for now we don't support screen share (waiting for server to support bundling, see SPARK-377812)
-       for sharing:
-          we have to call meeting.stopFloorRequest() before unpublishing a track
-          we have to call meeting.share() after publishing a track
-    */
-
-    // todo: depending on how muting is done with Local tracks, this code here might need to change...
-
-    if (track.kind === 'audio') {
-      this.meeting.setLocalAudioTrack(track);
-      this.meeting.mediaProperties.mediaDirection.sendAudio = true;
-
-      // audio state could be undefined if you have not sent audio before
-      this.meeting.audio =
-        this.meeting.audio ||
-        createMuteState(AUDIO, this.meeting, this.meeting.mediaProperties.mediaDirection);
-    } else if (track.kind === 'video') {
-      this.meeting.setLocalVideoTrack(track);
-      this.meeting.mediaProperties.mediaDirection.sendVideo = true;
-
-      // video state could be undefined if you have not sent video before
-      this.meeting.video =
-        this.meeting.video ||
-        createMuteState(VIDEO, this.meeting, this.meeting.mediaProperties.mediaDirection);
-    }
-
-    return this.meeting.mediaProperties.webrtcMediaConnection.publishTrack(track);
-  }
-
-  /**
-   * Unpublishes a local track in the meeting
-   *
-   * @param {MediaStreamTrack} track
-   * @returns {Promise}
-   */
-  unpublishTrack(track: MediaStreamTrack): Promise<void> {
-    // todo: see todos in publishTrack() - they all apply here too:
-    // screen sharing - SPARK-377812
-    // muting etc
-
-    if (track.kind === 'audio') {
-      this.meeting.setLocalVideoTrack(null);
-      this.meeting.mediaProperties.mediaDirection.sendAudio = false;
-    } else if (track.kind === 'video') {
-      this.meeting.setLocalAudioTrack(null);
-      this.meeting.mediaProperties.mediaDirection.sendVideo = false;
-    }
-    this.checkMediaConnection();
-
-    return this.meeting.mediaProperties.webrtcMediaConnection.unpublishTrack(track);
-  }
-}

package/src/peer-connection-manager/util.ts

@@ -1,117 +0,0 @@
-import { parse } from '@webex/ts-sdp';
-
-interface IPeerConnectionUtils {
-  convertCLineToIpv4: (sdp: string) => string;
-  adjustH264Profile: (sdp: string, maxFsValue: number) => string;
-}
-
-const PeerConnectionUtils = {} as IPeerConnectionUtils;
-
-// max-fs values for all H264 profile levels
-const maxFsForProfileLevel = {
-  10: 99,
-  11: 396,
-  12: 396,
-  13: 396,
-  20: 396,
-  21: 792,
-  22: 1620,
-  30: 1620,
-  31: 3600,
-  32: 5120,
-  40: 8192,
-  41: 8192,
-  42: 8704,
-  50: 22080,
-  51: 36864,
-  52: 36864,
-  60: 139264,
-  61: 139264,
-  62: 139264,
-};
-
-const framesPerSecond = 30;
-
-/**
- * Convert C line to IPv4
- * @param {string} sdp
- * @returns {string}
- */
-PeerConnectionUtils.convertCLineToIpv4 = (sdp: string) => {
-  let replaceSdp = sdp;
-
-  // TODO: remove this once linus supports Ipv6 c line.currently linus rejects SDP with c line having ipv6 candidates we are
-  // mocking ipv6 to ipv4 candidates
-  // https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-299232
-  replaceSdp = replaceSdp.replace(/c=IN IP6 .*/gi, 'c=IN IP4 0.0.0.0');
-
-  return replaceSdp;
-};
-
-/**
- * estimate profile levels for max-fs & max-mbps values
- * @param {string} sdp
- * @param {number} maxFsValue
- * @returns {string}
- */
-PeerConnectionUtils.adjustH264Profile = (sdp: string, maxFsValue: number) => {
-  // converting with ts-sdp parser, no munging
-  const parsedSdp = parse(sdp);
-
-  parsedSdp.avMedia.forEach((media) => {
-    if (media.type === 'video') {
-      media.codecs.forEach((codec) => {
-        if (codec.name?.toUpperCase() === 'H264') {
-          // there should really be just 1 fmtp line, but just in case, we process all of them
-          codec.fmtParams = codec.fmtParams.map((fmtp) => {
-            const parsedRegex = fmtp.match(/(.*)profile-level-id=(\w{4})(\w{2})(.*)/);
-
-            if (parsedRegex && parsedRegex.length === 5) {
-              const stuffBeforeProfileLevelId = parsedRegex[1];
-              const profile = parsedRegex[2].toLowerCase();
-              const levelId = parseInt(parsedRegex[3], 16);
-              const stuffAfterProfileLevelId = parsedRegex[4];
-
-              if (!maxFsForProfileLevel[levelId]) {
-                throw new Error(
-                  `found unsupported h264 profile level id value in the SDP: ${levelId}`
-                );
-              }
-
-              if (maxFsForProfileLevel[levelId] === maxFsValue) {
-                // profile level already matches our desired max-fs value, so we don't need to do anything
-                return fmtp;
-              }
-              if (maxFsForProfileLevel[levelId] < maxFsValue) {
-                // profile level has too low max-fs, so we need to override it (this is upgrading)
-                return `${fmtp};max-fs=${maxFsValue};max-mbps=${maxFsValue * framesPerSecond}`;
-              }
-
-              // profile level has too high max-fs value, so we need to use a lower level
-
-              // find highest level that has the matching maxFs
-              const newLevelId = Object.keys(maxFsForProfileLevel)
-                .reverse()
-                .find((key) => maxFsForProfileLevel[key] === maxFsValue);
-
-              if (newLevelId) {
-                // Object.keys returns keys as strings, so we need to parse it to an int again and then convert to hex
-                const newLevelIdHex = parseInt(newLevelId, 10).toString(16);
-
-                return `${stuffBeforeProfileLevelId}profile-level-id=${profile}${newLevelIdHex};max-mbps=${maxFsValue * framesPerSecond}${stuffAfterProfileLevelId}`;
-              }
-
-              throw new Error(`unsupported maxFsValue: ${maxFsValue}`);
-            }
-
-            return fmtp;
-          });
-        }
-      });
-    }
-  });
-
-  return parsedSdp.toString();
-};
-
-export default PeerConnectionUtils;

package/src/roap/request.js

@@ -1,127 +0,0 @@
-
-/* global window */
-import {StatelessWebexPlugin} from '@webex/webex-core';
-
-import LoggerProxy from '../common/logs/logger-proxy';
-import {
-  MEDIA,
-  HTTP_VERBS,
-  REACHABILITY
-} from '../constants';
-import Metrics from '../metrics';
-import {eventType} from '../metrics/config';
-
-/**
- * @class RoapRequest
- */
-export default class RoapRequest extends StatelessWebexPlugin {
-  /**
-   * Joins a meeting via ROAP
-   * @param {Object} options
-   * @returns {Promise} returns a promise that resolves/rejects whatever the request does
-   */
-
-
-  attachRechabilityData(localSdp) {
-    const reachabilityData = window.localStorage.getItem(REACHABILITY.localStorage);
-
-    if (reachabilityData) {
-      try {
-        const reachabilityResult = JSON.parse(reachabilityData);
-
-        /* istanbul ignore else */
-        if (reachabilityResult && Object.keys(reachabilityResult).length) {
-          localSdp.reachability = reachabilityResult;
-        }
-      }
-      catch (e) {
-        LoggerProxy.logger.error(`Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`);
-      }
-    }
-
-    return localSdp;
-  }
-
-  /**
-   * Sends a ROAP message
-   * @param {Object} options
-   * @param {Object} options.roapMessage
-   * @param {String} options.locusSelfUrl
-   * @param {String} options.mediaId
-   * @param {String} options.correlationId
-   * @param {Boolean} options.audioMuted
-   * @param {Boolean} options.videoMuted
-   * @param {String} options.meetingId
-   * @returns {Promise} returns the response/failure of the request
-   */
-  sendRoap(options) {
-    const {
-      roapMessage, locusSelfUrl, mediaId, correlationId, meetingId
-    } = options;
-
-    if (!mediaId) {
-      LoggerProxy.logger.info('Roap:request#sendRoap --> Race Condition /call mediaID not present');
-    }
-
-    const mediaUrl = `${locusSelfUrl}/${MEDIA}`;
-    const deviceUrl = this.webex.internal.device.url;
-
-    LoggerProxy.logger.info(`Roap:request#sendRoap --> ${mediaUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`);
-
-    Metrics.postEvent({event: eventType.MEDIA_REQUEST, meetingId});
-
-    return this.webex
-      .request({
-        uri: mediaUrl,
-        method: HTTP_VERBS.PUT,
-        body: {
-          device: {
-            url: deviceUrl,
-            deviceType: this.config.meetings.deviceType
-          },
-          correlationId,
-          localMedias: [
-            {
-              localSdp: JSON.stringify(this.attachRechabilityData({
-                roapMessage,
-                // eslint-disable-next-line no-warning-comments
-                // TODO: check whats the need for video and audiomute
-                audioMuted: !!options.audioMuted,
-                videoMuted: !!options.videoMuted
-              })),
-              mediaId: options.mediaId
-            }
-          ],
-          clientMediaPreferences: {
-            preferTranscoding: options.preferTranscoding ?? true
-          }
-        }
-      })
-      .then((res) => {
-        Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId});
-
-        // always it will be the first mediaConnection Object
-        const mediaConnections = res.body.mediaConnections && res.body.mediaConnections.length > 0 && res.body.mediaConnections[0];
-
-        LoggerProxy.logger.info(
-          `Roap:request#sendRoap --> response:${JSON.stringify(mediaConnections, null, 2)}'\n StatusCode:'${res.statusCode}`
-        );
-        const {locus} = res.body;
-
-        locus.roapSeq = options.roapMessage.seq;
-
-        return {
-          locus,
-          ...(mediaConnections && {mediaConnections: res.body.mediaConnections})
-        };
-      })
-      .catch((err) => {
-        Metrics.postEvent({event: eventType.MEDIA_RESPONSE, meetingId, data: {error: Metrics.parseLocusError(err, true)}});
-        LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`);
-        LoggerProxy.logger.error(
-          `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(roapMessage, null, 2)} + '\\n mediaId:'${options.mediaId}`
-        );
-        throw err;
-      });
-  }
-}

package/src/statsAnalyzer/global.js

@@ -1,133 +0,0 @@
-const STATS_DEFAULT = {
-  encryption: 'sha-256',
-  audio: {
-    send: {
-      trackLabel: '',
-      maxPacketLossRatio: 0,
-      availableBandwidth: 0,
-      bytesSent: 0,
-      meanRemoteJitter: [],
-      meanRoundTripTime: []
-    },
-    recv: {
-      availableBandwidth: 0,
-      bytesReceived: 0,
-      meanRtpJitter: [],
-      meanRoundTripTime: []
-    }
-  },
-  video: {
-    send: {
-      trackLabel: '',
-      maxPacketLossRatio: 0,
-      availableBandwidth: 0,
-      meanRemoteJitter: [],
-      meanRoundTripTime: []
-    },
-    recv: {
-      availableBandwidth: 0,
-      totalPacketsLost: 0,
-      meanRtpJitter: [],
-      meanRoundTripTime: []
-
-    },
-    latency: 0,
-    packetsLost: 0
-  },
-  share: {
-    send: {
-      maxPacketLossRatio: 0,
-      availableBandwidth: 0,
-      totalPacketsLost: 0,
-      meanRemoteJitter: [],
-      meanRoundTripTime: []
-    },
-    recv: {
-      availableBandwidth: 0,
-      meanRtpJitter: [],
-      meanRoundTripTime: []
-    },
-
-    latency: 0,
-    packetsLost: 0
-  },
-  bandwidth: {
-    systemBandwidth: 0,
-    sentPerSecond: 0,
-    encodedPerSecond: 0,
-    helper: {
-      audioBytesSent: 0,
-      videoBytestSent: 0
-    },
-    speed: 0
-  },
-  results: {},
-  connectionType: {
-    systemNetworkType: 'unknown',
-    systemIpAddress: '0.0.0.0',
-    local: {
-      candidateType: [],
-      transport: [],
-      ipAddress: [],
-      networkType: []
-    },
-    remote: {
-      candidateType: [],
-      transport: [],
-      ipAddress: [],
-      networkType: []
-    }
-  },
-  resolutions: {
-    audio: {
-      send: {
-        width: 0,
-        height: 0
-      },
-      recv: {
-        width: 0,
-        height: 0
-      }
-    },
-    video: {
-      send: {
-        width: 0,
-        height: 0
-      },
-      recv: {
-        width: 0,
-        height: 0
-      }
-    },
-    share: {
-      send: {
-        width: 0,
-        height: 0
-      },
-      recv: {
-        width: 0,
-        height: 0
-      }
-    }
-  },
-  internal: {
-    audio: {
-      send: {},
-      recv: {}
-    },
-    video: {
-      send: {},
-      recv: {}
-    },
-    share: {
-      send: {},
-      recv: {}
-    },
-    remote: {
-
-    },
-    candidates: {}
-  }
-};
-
-export default STATS_DEFAULT;