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

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

@@ -0,0 +1,119 @@
+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/reachability/index.ts

@@ -4,11 +4,9 @@
 
 /* eslint-disable class-methods-use-this */
 /* globals window */
-import {uniq, mapValues, pick} from 'lodash';
+import _ from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
-import MeetingUtil from '../meeting/util';
-
 import {ICE_GATHERING_STATE, CONNECTION_STATE, REACHABILITY} from '../constants';
 
 import ReachabilityRequest from './request';
@@ -16,56 +14,11 @@ import ReachabilityRequest from './request';
 const DEFAULT_TIMEOUT = 3000;
 const VIDEO_MESH_TIMEOUT = 1000;
 
-export type ReachabilityMetrics = {
-  reachability_public_udp_success: number;
-  reachability_public_udp_failed: number;
-  reachability_public_tcp_success: number;
-  reachability_public_tcp_failed: number;
-  reachability_vmn_udp_success: number;
-  reachability_vmn_udp_failed: number;
-  reachability_vmn_tcp_success: number;
-  reachability_vmn_tcp_failed: number;
-};
-
-// result for a specific transport protocol (like udp or tcp)
-export type TransportResult = {
-  reachable?: 'true' | 'false';
-  latencyInMilliseconds?: string;
-  clientMediaIPs?: string[];
-  untested?: 'true';
-};
-
-// reachability result for a specifc media cluster
-type ReachabilityResult = {
-  udp: TransportResult;
-  tcp: TransportResult;
-  xtls: {
-    untested: 'true';
-  };
-};
-// this is the type that is required by the backend when we send them reachability results
-export type ReachabilityResults = Record<string, ReachabilityResult>;
-
-// this is the type used by Reachability class internally and stored in local storage
-type InternalReachabilityResults = Record<
-  string,
-  ReachabilityResult & {
-    isVideoMesh?: boolean;
-  }
->;
-
-export type ICECandidateResult = {
-  clusterId: string;
-  isVideoMesh: boolean;
-  elapsed?: string | null;
-  publicIPs?: string[];
-};
 /**
  * @class Reachability
  * @export
  */
 export default class Reachability {
-  namespace = REACHABILITY.namespace;
   webex: object;
   reachabilityRequest: any;
   clusterLatencyResults: any;
@@ -104,36 +57,28 @@ export default class Reachability {
    * @async
    * @memberof Reachability
    */
-  public async gatherReachability(): Promise<InternalReachabilityResults> {
+  public async gatherReachability() {
     this.setup();
 
     // Remove stored reachability results to ensure no stale data
-    // @ts-ignore
-    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageResult);
-    // @ts-ignore
-    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageJoinCookie);
+    if (window?.localStorage?.removeItem) {
+      window.localStorage.removeItem(REACHABILITY.localStorage);
+    } else {
+      LoggerProxy.logger.error(
+        'Reachability:index#gatherReachability --> Error in accessing LocalStorage.'
+      );
+
+      return {};
+    }
 
     // Fetch clusters and measure latency
     try {
-      const {clusters, joinCookie} = await this.reachabilityRequest.getClusters(
-        MeetingUtil.getIpVersion(this.webex)
-      );
+      const clusters = await this.reachabilityRequest.getClusters();
 
       // Perform Reachability Check
       const results = await this.performReachabilityCheck(clusters);
 
-      // @ts-ignore
-      await this.webex.boundedStorage.put(
-        this.namespace,
-        REACHABILITY.localStorageResult,
-        JSON.stringify(results)
-      );
-      // @ts-ignore
-      await this.webex.boundedStorage.put(
-        this.namespace,
-        REACHABILITY.localStorageJoinCookie,
-        JSON.stringify(joinCookie)
-      );
+      window.localStorage.setItem(REACHABILITY.localStorage, JSON.stringify(results));
 
       LoggerProxy.logger.log(
         'Reachability:index#gatherReachability --> Reachability checks completed'
@@ -149,111 +94,22 @@ export default class Reachability {
     }
   }
 
-  /**
-   * Returns statistics about last reachability results. The returned value is an object
-   * with a flat list of properties so that it can be easily sent with metrics
-   *
-   * @returns {Promise} Promise with metrics values, it never rejects/throws.
-   */
-  async getReachabilityMetrics(): Promise<ReachabilityMetrics> {
-    const stats: ReachabilityMetrics = {
-      reachability_public_udp_success: 0,
-      reachability_public_udp_failed: 0,
-      reachability_public_tcp_success: 0,
-      reachability_public_tcp_failed: 0,
-      reachability_vmn_udp_success: 0,
-      reachability_vmn_udp_failed: 0,
-      reachability_vmn_tcp_success: 0,
-      reachability_vmn_tcp_failed: 0,
-    };
-
-    const updateStats = (clusterType: 'public' | 'vmn', result: ReachabilityResult) => {
-      if (result.udp?.reachable) {
-        const outcome = result.udp.reachable === 'true' ? 'success' : 'failed';
-        stats[`reachability_${clusterType}_udp_${outcome}`] += 1;
-      }
-      if (result.tcp?.reachable) {
-        const outcome = result.tcp.reachable === 'true' ? 'success' : 'failed';
-        stats[`reachability_${clusterType}_tcp_${outcome}`] += 1;
-      }
-    };
-
-    try {
-      // @ts-ignore
-      const resultsJson = await this.webex.boundedStorage.get(
-        REACHABILITY.namespace,
-        REACHABILITY.localStorageResult
-      );
-
-      const internalResults: InternalReachabilityResults = JSON.parse(resultsJson);
-
-      Object.values(internalResults).forEach((result) => {
-        updateStats(result.isVideoMesh ? 'vmn' : 'public', result);
-      });
-    } catch (e) {
-      // empty storage, that's ok
-      LoggerProxy.logger.warn(
-        'Roap:request#getReachabilityMetrics --> Error parsing reachability data: ',
-        e
-      );
-    }
-
-    return stats;
-  }
-
-  /**
-   * Reachability results as an object in the format that backend expects
-   *
-   * @returns {any} reachability results that need to be sent to the backend
-   */
-  async getReachabilityResults(): Promise<ReachabilityResults | undefined> {
-    let results: ReachabilityResults;
-
-    // these are the only props that backend needs in the reachability results:
-    const reachabilityResultsProps: Array<keyof ReachabilityResult> = ['udp', 'tcp', 'xtls'];
-
-    try {
-      // @ts-ignore
-      const resultsJson = await this.webex.boundedStorage.get(
-        REACHABILITY.namespace,
-        REACHABILITY.localStorageResult
-      );
-
-      const internalResults: InternalReachabilityResults = JSON.parse(resultsJson);
-
-      results = mapValues(internalResults, (result) => pick(result, reachabilityResultsProps));
-    } catch (e) {
-      // empty storage, that's ok
-      LoggerProxy.logger.warn(
-        'Roap:request#attachReachabilityData --> Error parsing reachability data: ',
-        e
-      );
-    }
-
-    return results;
-  }
-
   /**
    * fetches reachability data and checks for cluster reachability
    * @returns {boolean}
    * @public
    * @memberof Reachability
    */
-  async isAnyPublicClusterReachable() {
+  isAnyClusterReachable() {
     let reachable = false;
-    // @ts-ignore
-    const reachabilityData = await this.webex.boundedStorage
-      .get(this.namespace, REACHABILITY.localStorageResult)
-      .catch(() => {});
+    const reachabilityData = window.localStorage.getItem(REACHABILITY.localStorage);
 
     if (reachabilityData) {
       try {
-        const reachabilityResults: InternalReachabilityResults = JSON.parse(reachabilityData);
+        const reachabilityResults = JSON.parse(reachabilityData);
 
         reachable = Object.values(reachabilityResults).some(
-          (result) =>
-            !result.isVideoMesh &&
-            (result.udp?.reachable === 'true' || result.tcp?.reachable === 'true')
+          (result: any) => result.udp?.reachable === 'true' || result.tcp?.reachable === 'true'
         );
       } catch (e) {
         LoggerProxy.logger.error(
@@ -273,7 +129,7 @@ export default class Reachability {
    * @memberof Reachability
    */
   private buildPeerConnectionConfig(cluster: any) {
-    const iceServers = uniq(cluster.udp).map((url) => ({
+    const iceServers = _.uniq([...cluster.udp, ...cluster.tcp]).map((url) => ({
       username: '',
       credential: '',
       urls: [url],
@@ -334,7 +190,7 @@ export default class Reachability {
    * @private
    * @memberof Reachability
    */
-  private getLocalSDPForClusters(clusterList: object): Promise<InternalReachabilityResults> {
+  private getLocalSDPForClusters(clusterList: object) {
     let clusters: any[] = [...Object.keys(clusterList)];
 
     clusters = clusters.map(async (key) => {
@@ -347,17 +203,18 @@ export default class Reachability {
       peerConnection.begin = Date.now();
       peerConnection.setLocalDescription(description);
 
-      return this.iceGatheringState(peerConnection, cluster.isVideoMesh).catch(
-        (iceGatheringStateError) => {
-          LoggerProxy.logger.log(
-            `Reachability:index#getLocalSDPForClusters --> Error in getLocalSDP : ${iceGatheringStateError}`
-          );
-        }
-      );
+      return this.iceGatheringState(
+        peerConnection,
+        cluster.isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT
+      ).catch((iceGatheringStateError) => {
+        LoggerProxy.logger.log(
+          `Reachability:index#getLocalSDPForClusters --> Error in getLocalSDP : ${iceGatheringStateError}`
+        );
+      });
     });
 
     return Promise.all(clusters)
-      .then(this.parseIceResultsToInternalReachabilityResults)
+      .then(this.parseIceResultsToReachabilityResults)
       .then((reachabilityLatencyResults) => {
         this.logUnreachableClusters();
 
@@ -433,8 +290,6 @@ export default class Reachability {
           `Reachability:index#onIceCandidate --> Successfully pinged ${peerConnection.key}:`,
           elapsed
         );
-        // order is important
-        this.addPublicIP(peerConnection, e.candidate.address);
         this.setLatencyAndClose(peerConnection, elapsed);
       }
     };
@@ -446,17 +301,14 @@ export default class Reachability {
    * speed.
    * @private
    * @param {RTCPeerConnection} peerConnection
-   * @param {boolean} isVideoMesh
+   * @param {number} timeout
    * @returns {Promise}
    */
-  private iceGatheringState(peerConnection: RTCPeerConnection, isVideoMesh: boolean) {
+  private iceGatheringState(peerConnection: RTCPeerConnection, timeout: number) {
     const ELAPSED = 'elapsed';
 
-    const timeout = isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT;
-
-    return new Promise<ICECandidateResult>((resolve) => {
+    return new Promise((resolve) => {
       const peerConnectionProxy = new window.Proxy(peerConnection, {
-        // eslint-disable-next-line require-jsdoc
         get(target, property) {
           const targetMember = target[property];
 
@@ -469,14 +321,8 @@ export default class Reachability {
         set: (target, property, value) => {
           // only intercept elapsed property
           if (property === ELAPSED) {
-            resolve({
-              // @ts-ignore
-              clusterId: peerConnection.key,
-              isVideoMesh,
-              // @ts-ignore
-              publicIPs: target.publicIPs,
-              elapsed: value,
-            });
+            // @ts-ignore
+            resolve({clusterId: peerConnection.key, elapsed: value});
 
             return true;
           }
@@ -497,8 +343,6 @@ export default class Reachability {
 
         // Close any open peerConnections
         if (peerConnectionProxy.connectionState !== CLOSED) {
-          // order is important
-          this.addPublicIP(peerConnectionProxy, null);
           this.setLatencyAndClose(peerConnectionProxy, null);
         }
       }, timeout);
@@ -523,39 +367,29 @@ export default class Reachability {
 
   /**
    * Calculates time to establish connection
-   * @param {Array<ICECandidateResult>} iceResults iceResults
+   * @param {array} iceResults iceResults
    * @returns {object} reachabilityMap
-   * @protected
+   * @private
    * @memberof Reachability
    */
-  protected parseIceResultsToInternalReachabilityResults(
-    iceResults: Array<ICECandidateResult>
-  ): InternalReachabilityResults {
+  private parseIceResultsToReachabilityResults(iceResults: Array<any>) {
     const reachabilityMap = {};
 
-    iceResults.forEach(({clusterId, isVideoMesh, elapsed, publicIPs}) => {
-      const latencyResult = {};
+    iceResults.forEach(({clusterId, elapsed}) => {
+      let latencyResult;
 
-      if (!elapsed) {
-        Object.assign(latencyResult, {reachable: 'false'});
+      if (elapsed === null) {
+        latencyResult = {reachable: 'false'};
       } else {
-        Object.assign(latencyResult, {
+        latencyResult = {
           reachable: 'true',
           latencyInMilliseconds: elapsed.toString(),
-        });
-      }
-
-      if (publicIPs) {
-        Object.assign(latencyResult, {
-          clientMediaIPs: publicIPs,
-        });
+        };
       }
 
       reachabilityMap[clusterId] = {
         udp: latencyResult,
-        tcp: {untested: 'true'},
-        xtls: {untested: 'true'},
-        isVideoMesh,
+        tcp: latencyResult,
       };
     });
 
@@ -565,11 +399,11 @@ export default class Reachability {
   /**
    * fetches reachability data
    * @param {object} clusterList
-   * @returns {Promise<InternalReachabilityResults>} reachability check results
+   * @returns {Promise<localSDPData>} reachability check results
    * @private
    * @memberof Reachability
    */
-  private performReachabilityCheck(clusterList: object): Promise<InternalReachabilityResults> {
+  private performReachabilityCheck(clusterList: object) {
     if (!clusterList || !Object.keys(clusterList).length) {
       return Promise.resolve({});
     }
@@ -596,33 +430,6 @@ export default class Reachability {
     });
   }
 
-  /**
-   * Adds public IP (client media IPs)
-   * @param {RTCPeerConnection} peerConnection
-   * @param {string} publicIP
-   * @returns {void}
-   */
-  protected addPublicIP(peerConnection: RTCPeerConnection, publicIP?: string | null) {
-    const modifiedPeerConnection: RTCPeerConnection & {publicIPs?: string[]} = peerConnection;
-    const {CLOSED} = CONNECTION_STATE;
-
-    if (modifiedPeerConnection.connectionState === CLOSED) {
-      LoggerProxy.logger.log(
-        `Reachability:index#addPublicIP --> Attempting to set publicIP of ${publicIP} on closed peerConnection.`
-      );
-    }
-
-    if (publicIP) {
-      if (modifiedPeerConnection.publicIPs) {
-        modifiedPeerConnection.publicIPs.push(publicIP);
-      } else {
-        modifiedPeerConnection.publicIPs = [publicIP];
-      }
-    } else {
-      modifiedPeerConnection.publicIPs = null;
-    }
-  }
-
   /**
    * Records latency and closes the peerConnection
    * @param {RTCPeerConnection} peerConnection

package/src/reachability/request.ts

@@ -1,5 +1,5 @@
 import LoggerProxy from '../common/logs/logger-proxy';
-import {HTTP_VERBS, RESOURCE, API, IP_VERSION} from '../constants';
+import {HTTP_VERBS, RESOURCE, API} from '../constants';
 
 export interface ClusterNode {
   isVideoMesh: boolean;
@@ -28,40 +28,31 @@ class ReachabilityRequest {
   }
 
   /**
-   * Gets the cluster information
+   * gets the cluster information
    *
-   * @param {IP_VERSION} ipVersion information about current ip network we're on
+   * @param {boolean} includeVideoMesh whether to include the video mesh clusters in the result or not
    * @returns {Promise}
    */
-  getClusters = (ipVersion?: IP_VERSION): Promise<{clusters: ClusterList; joinCookie: any}> =>
+  getClusters = (): Promise<ClusterList> =>
     this.webex
       .request({
         method: HTTP_VERBS.GET,
         shouldRefreshAccessToken: false,
         api: API.CALLIOPEDISCOVERY,
         resource: RESOURCE.CLUSTERS,
-        qs: {
-          JCSupport: 1,
-          ipver: ipVersion,
-        },
       })
       .then((res) => {
-        const {clusters, joinCookie} = res.body;
+        const {clusters} = res.body;
 
         Object.keys(clusters).forEach((key) => {
-          clusters[key].isVideoMesh = !!res.body.clusterClasses?.hybridMedia?.includes(key);
+          clusters[key].isVideoMesh = res.body.clusterClasses?.hybridMedia?.includes(key);
         });
 
         LoggerProxy.logger.log(
-          `Reachability:request#getClusters --> get clusters (ipver=${ipVersion}) successful:${JSON.stringify(
-            clusters
-          )}`
+          `Reachability:request#getClusters --> get clusters successful:${JSON.stringify(clusters)}`
         );
 
-        return {
-          clusters,
-          joinCookie,
-        };
+        return clusters;
       });
 
   /**

package/src/reactions/reactions.ts

@@ -1,6 +1,6 @@
-import {Reaction, ReactionServerType, SkinTone, SkinToneType} from './reactions.type';
+import {Reaction, ReactionType, SkinTone, SkinToneType} from './reactions.type';
 
-const Reactions: Record<ReactionServerType, Reaction> = {
+const Reactions: Record<ReactionType, Reaction> = {
   smile: {
     type: 'smile',
     codepoints: '1F642',
@@ -31,12 +31,12 @@ const Reactions: Record<ReactionServerType, Reaction> = {
     codepoints: '1F44F',
     shortcodes: ':clap:',
   },
-  thumb_up: {
+  thumbs_up: {
     type: 'thumb_up',
     codepoints: '1F44D',
     shortcodes: ':thumbsup:',
   },
-  thumb_down: {
+  thumbs_down: {
     type: 'thumb_down',
     codepoints: '1F44E',
     shortcodes: ':thumbsdown:',

package/src/reactions/reactions.type.ts

@@ -1,5 +1,3 @@
-import {REACTION_RELAY_TYPES} from './constants';
-
 export type EmoticonData = {
   type: string;
   codepoints?: string;
@@ -7,21 +5,20 @@ export type EmoticonData = {
 };
 
 export type SkinTone = EmoticonData;
-
+// @ts-ignore
 export type Reaction = EmoticonData & {
   tone?: SkinTone;
 };
 
-// eslint-disable-next-line no-shadow
-export enum ReactionServerType {
+export enum ReactionType {
   smile = 'smile',
   sad = 'sad',
   wow = 'wow',
   haha = 'haha',
   celebrate = 'celebrate',
   clap = 'clap',
-  thumb_up = 'thumb_up',
-  thumb_down = 'thumb_down',
+  thumbs_up = 'thumbs_up',
+  thumbs_down = 'thumbs_down',
   heart = 'heart',
   fire = 'fire',
   prayer = 'prayer',
@@ -29,7 +26,6 @@ export enum ReactionServerType {
   slow_down = 'slow_down',
 }
 
-// eslint-disable-next-line no-shadow
 export enum SkinToneType {
   normal = 'normal',
   light = 'light',
@@ -38,25 +34,3 @@ export enum SkinToneType {
   medium_dark = 'medium_dark',
   dark = 'dark',
 }
-
-export type Sender = {
-  participantId: string;
-};
-
-export type ProcessedReaction = {
-  reaction: Reaction;
-  sender: {
-    id: Sender['participantId'];
-    name: string;
-  };
-};
-
-type RelayEventData = {
-  relayType: (typeof REACTION_RELAY_TYPES)['REACTION'];
-  reaction: Reaction;
-  sender: Sender;
-};
-
-export type RelayEvent = {
-  data: RelayEventData;
-};