@webex/plugin-meetings 3.0.0-beta.10 → 3.0.0-beta.104

package/src/reachability/index.ts

@@ -7,22 +7,20 @@
 import _ from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
-import {
-  ICE_GATHERING_STATE,
-  CONNECTION_STATE,
-  REACHABILITY
-} from '../constants';
+import {ICE_GATHERING_STATE, CONNECTION_STATE, REACHABILITY} from '../constants';
 
 import ReachabilityRequest from './request';
 
 const DEFAULT_TIMEOUT = 3000;
 const VIDEO_MESH_TIMEOUT = 1000;
 
+export type ICECandidateResult = {clusterId: string; elapsed?: string | null; publicIPs?: string[]};
 /**
  * @class Reachability
  * @export
  */
 export default class Reachability {
+  namespace = REACHABILITY.namespace;
   webex: object;
   reachabilityRequest: any;
   clusterLatencyResults: any;
@@ -54,7 +52,6 @@ export default class Reachability {
     this.clusterLatencyResults = {};
   }
 
-
   /**
    * fetches reachability data
    * @returns {Object} reachability data
@@ -66,30 +63,40 @@ export default class Reachability {
     this.setup();
 
     // Remove stored reachability results to ensure no stale data
-    if (window?.localStorage?.removeItem) {
-      window.localStorage.removeItem(REACHABILITY.localStorage);
-    }
-    else {
-      LoggerProxy.logger.error('Reachability:index#gatherReachability --> Error in accessing LocalStorage.');
-
-      return {};
-    }
+    // @ts-ignore
+    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageResult);
+    // @ts-ignore
+    await this.webex.boundedStorage.del(this.namespace, REACHABILITY.localStorageJoinCookie);
 
     // Fetch clusters and measure latency
     try {
-      const clusters = await this.reachabilityRequest.getClusters();
+      const {clusters, joinCookie} = await this.reachabilityRequest.getClusters();
 
       // Perform Reachability Check
       const results = await this.performReachabilityCheck(clusters);
 
-      window.localStorage.setItem(REACHABILITY.localStorage, JSON.stringify(results));
+      // @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)
+      );
 
-      LoggerProxy.logger.log('Reachability:index#gatherReachability --> Reachability checks completed');
+      LoggerProxy.logger.log(
+        'Reachability:index#gatherReachability --> Reachability checks completed'
+      );
 
       return results;
-    }
-    catch (getClusterError) {
-      LoggerProxy.logger.error(`Reachability:index#gatherReachability --> Error in calling getClusters(): ${getClusterError}`);
+    } catch (getClusterError) {
+      LoggerProxy.logger.error(
+        `Reachability:index#gatherReachability --> Error in calling getClusters(): ${getClusterError}`
+      );
 
       return {};
     }
@@ -101,25 +108,30 @@ export default class Reachability {
    * @public
    * @memberof Reachability
    */
-  isAnyClusterReachable() {
+  async isAnyClusterReachable() {
     let reachable = false;
-    const reachabilityData = window.localStorage.getItem(REACHABILITY.localStorage);
+    // @ts-ignore
+    const reachabilityData = await this.webex.boundedStorage
+      .get(this.namespace, REACHABILITY.localStorageResult)
+      .catch(() => {});
 
     if (reachabilityData) {
       try {
         const reachabilityResults = JSON.parse(reachabilityData);
 
-        reachable = Object.values(reachabilityResults).some((result: any) => result.udp?.reachable === 'true' || result.tcp?.reachable === 'true');
-      }
-      catch (e) {
-        LoggerProxy.logger.error(`Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`);
+        reachable = Object.values(reachabilityResults).some(
+          (result: any) => result.udp?.reachable === 'true' || result.tcp?.reachable === 'true'
+        );
+      } catch (e) {
+        LoggerProxy.logger.error(
+          `Roap:request#attachReachabilityData --> Error in parsing reachability data: ${e}`
+        );
       }
     }
 
     return reachable;
   }
 
-
   /**
    * Generate peerConnection config settings
    * @param {object} cluster
@@ -128,25 +140,19 @@ export default class Reachability {
    * @memberof Reachability
    */
   private buildPeerConnectionConfig(cluster: any) {
-    const iceServers = _.uniq([
-      ...cluster.udp,
-      ...cluster.tcp
-    ]).map((url) => ({
+    const iceServers = _.uniq([...cluster.udp, ...cluster.tcp]).map((url) => ({
       username: '',
       credential: '',
-      urls: [url]
+      urls: [url],
     }));
 
     return {
-      iceServers: [
-        ...iceServers
-      ],
+      iceServers: [...iceServers],
       iceCandidatePoolSize: '0',
-      iceTransportPolicy: 'all'
+      iceTransportPolicy: 'all',
     };
   }
 
-
   /**
    * Creates an RTCPeerConnection
    * @param {object} cluster
@@ -164,15 +170,15 @@ export default class Reachability {
       peerConnection.key = key;
 
       return peerConnection;
-    }
-    catch (peerConnectionError) {
-      LoggerProxy.logger.log(`Reachability:index#createPeerConnection --> Error creating peerConnection: ${peerConnectionError}`);
+    } catch (peerConnectionError) {
+      LoggerProxy.logger.log(
+        `Reachability:index#createPeerConnection --> Error creating peerConnection: ${peerConnectionError}`
+      );
 
       return null;
     }
   }
 
-
   /**
    * Gets total elapsed time
    * @param {RTCPeerConnection} peerConnection
@@ -188,7 +194,6 @@ export default class Reachability {
     return Date.now() - startTime;
   }
 
-
   /**
    * creates offer and generates localSDP
    * @param {object} clusterList cluster List
@@ -209,10 +214,14 @@ export default class Reachability {
       peerConnection.begin = Date.now();
       peerConnection.setLocalDescription(description);
 
-      return this.iceGatheringState(peerConnection, cluster.isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT)
-        .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)
@@ -225,7 +234,6 @@ export default class Reachability {
       });
   }
 
-
   /**
    * Get list of all unreachable clusters
    * @returns {array} Unreachable clusters
@@ -247,7 +255,6 @@ export default class Reachability {
     return unreachableList;
   }
 
-
   /**
    * Attach an event handler for the icegatheringstatechange
    * event and measure latency.
@@ -264,13 +271,16 @@ export default class Reachability {
         const elapsed = this.getElapsedTime(peerConnection);
 
         // @ts-ignore
-        LoggerProxy.logger.log(`Reachability:index#onIceGatheringStateChange --> Successfully pinged ${peerConnection.key}:`, elapsed);
+        LoggerProxy.logger.log(
+          // @ts-ignore
+          `Reachability:index#onIceGatheringStateChange --> Successfully pinged ${peerConnection.key}:`,
+          elapsed
+        );
         this.setLatencyAndClose(peerConnection, elapsed);
       }
     };
   }
 
-
   /**
    * Attach an event handler for the icecandidate
    * event and measure latency.
@@ -286,8 +296,13 @@ export default class Reachability {
       if (e.candidate && String(e.candidate.type).toLowerCase() === SERVER_REFLEXIVE) {
         const elapsed = this.getElapsedTime(peerConnection);
 
-        // @ts-ignore
-        LoggerProxy.logger.log(`Reachability:index#onIceCandidate --> Successfully pinged ${peerConnection.key}:`, elapsed);
+        LoggerProxy.logger.log(
+          // @ts-ignore
+          `Reachability:index#onIceCandidate --> Successfully pinged ${peerConnection.key}:`,
+          elapsed
+        );
+        // order is important
+        this.addPublicIP(peerConnection, e.candidate.address);
         this.setLatencyAndClose(peerConnection, elapsed);
       }
     };
@@ -305,12 +320,13 @@ export default class Reachability {
   private iceGatheringState(peerConnection: RTCPeerConnection, timeout: number) {
     const ELAPSED = 'elapsed';
 
-    return new Promise((resolve) => {
+    return new Promise<ICECandidateResult>((resolve) => {
       const peerConnectionProxy = new window.Proxy(peerConnection, {
+        // eslint-disable-next-line require-jsdoc
         get(target, property) {
           const targetMember = target[property];
 
-          if (typeof (targetMember) === 'function') {
+          if (typeof targetMember === 'function') {
             return targetMember.bind(target);
           }
 
@@ -320,14 +336,14 @@ export default class Reachability {
           // only intercept elapsed property
           if (property === ELAPSED) {
             // @ts-ignore
-            resolve({clusterId: peerConnection.key, elapsed: value});
+            resolve({clusterId: peerConnection.key, publicIPs: target.publicIPs, elapsed: value});
 
             return true;
           }
 
           // pass thru
           return window.Reflect.set(target, property, value);
-        }
+        },
       });
 
       // Using peerConnection proxy so handle functions below
@@ -341,13 +357,14 @@ export default class Reachability {
 
         // Close any open peerConnections
         if (peerConnectionProxy.connectionState !== CLOSED) {
+          // order is important
+          this.addPublicIP(peerConnectionProxy, null);
           this.setLatencyAndClose(peerConnectionProxy, null);
         }
       }, timeout);
     });
   }
 
-
   /**
    * Make a log of unreachable clusters.
    * @returns {undefined}
@@ -358,44 +375,49 @@ export default class Reachability {
     const list = this.getUnreachablClusters();
 
     list.forEach((cluster) => {
-      LoggerProxy.logger.log(`Reachability:index#logUnreachableClusters --> No ice candidate for ${cluster}.`);
+      LoggerProxy.logger.log(
+        `Reachability:index#logUnreachableClusters --> No ice candidate for ${cluster}.`
+      );
     });
   }
 
-
   /**
    * Calculates time to establish connection
-   * @param {array} iceResults iceResults
+   * @param {Array<ICECandidateResult>} iceResults iceResults
    * @returns {object} reachabilityMap
-   * @private
+   * @protected
    * @memberof Reachability
    */
-  private parseIceResultsToReachabilityResults(iceResults: Array<any>) {
+  protected parseIceResultsToReachabilityResults(iceResults: Array<ICECandidateResult>) {
     const reachabilityMap = {};
 
-    iceResults.forEach(({clusterId, elapsed}) => {
-      let latencyResult;
+    iceResults.forEach(({clusterId, elapsed, publicIPs}) => {
+      const latencyResult = {};
 
-      if (elapsed === null) {
-        latencyResult = {reachable: 'false'};
-      }
-      else {
-        latencyResult = {
+      if (!elapsed) {
+        Object.assign(latencyResult, {reachable: 'false'});
+      } else {
+        Object.assign(latencyResult, {
           reachable: 'true',
-          latencyInMilliseconds: (elapsed).toString()
-        };
+          latencyInMilliseconds: elapsed.toString(),
+        });
+      }
+
+      if (publicIPs) {
+        Object.assign(latencyResult, {
+          clientMediaIPs: publicIPs,
+        });
       }
 
       reachabilityMap[clusterId] = {
         udp: latencyResult,
-        tcp: latencyResult
+        tcp: latencyResult,
       };
     });
 
     return reachabilityMap;
   }
 
-
   /**
    * fetches reachability data
    * @param {object} clusterList
@@ -413,20 +435,49 @@ export default class Reachability {
         .then((localSDPData) => {
           if (!localSDPData || !Object.keys(localSDPData).length) {
             // TODO: handle the error condition properly and try retry
-            LoggerProxy.logger.log('Reachability:index#performReachabilityCheck --> Local SDP is empty or has missing elements..returning');
+            LoggerProxy.logger.log(
+              'Reachability:index#performReachabilityCheck --> Local SDP is empty or has missing elements..returning'
+            );
             resolve({});
-          }
-          else {
+          } else {
             resolve(localSDPData);
           }
         })
         .catch((error) => {
-          LoggerProxy.logger.error(`Reachability:index#performReachabilityCheck --> Error in getLocalSDPForClusters: ${error}`);
+          LoggerProxy.logger.error(
+            `Reachability:index#performReachabilityCheck --> Error in getLocalSDPForClusters: ${error}`
+          );
           resolve({});
         });
     });
   }
 
+  /**
+   * 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
@@ -446,7 +497,9 @@ export default class Reachability {
     const intialState = {[REACHABLE]: 0, [UNREACHABLE]: 0};
 
     if (peerConnection.connectionState === CLOSED) {
-      LoggerProxy.logger.log(`Reachability:index#setLatencyAndClose --> Attempting to set latency of ${elapsed} on closed peerConnection.`);
+      LoggerProxy.logger.log(
+        `Reachability:index#setLatencyAndClose --> Attempting to set latency of ${elapsed} on closed peerConnection.`
+      );
 
       return;
     }
@@ -462,7 +515,6 @@ export default class Reachability {
     peerConnection.elapsed = elapsed;
   }
 
-
   /**
    * utility function
    * @returns {undefined}

package/src/reachability/request.ts

@@ -1,9 +1,5 @@
 import LoggerProxy from '../common/logs/logger-proxy';
-import {
-  HTTP_VERBS,
-  RESOURCE,
-  API
-} from '../constants';
+import {HTTP_VERBS, RESOURCE, API} from '../constants';
 
 export interface ClusterNode {
   isVideoMesh: boolean;
@@ -13,8 +9,8 @@ export interface ClusterNode {
 }
 
 export type ClusterList = {
-  [key:string]: ClusterNode;
-}
+  [key: string]: ClusterNode;
+};
 
 /**
  * @class ReachabilityRequest
@@ -32,46 +28,59 @@ class ReachabilityRequest {
   }
 
   /**
-   * gets the cluster information
+   * Gets the cluster information
    *
-   * @param {boolean} includeVideoMesh whether to include the video mesh clusters in the result or not
    * @returns {Promise}
    */
-  getClusters = (): Promise<ClusterList> => this.webex.request({
-    method: HTTP_VERBS.GET,
-    shouldRefreshAccessToken: false,
-    api: API.CALLIOPEDISCOVERY,
-    resource: RESOURCE.CLUSTERS
-  })
-    .then((res) => {
-      const {clusters} = res.body;
+  getClusters = (): Promise<{clusters: ClusterList; joinCookie: any}> =>
+    this.webex
+      .request({
+        method: HTTP_VERBS.GET,
+        shouldRefreshAccessToken: false,
+        api: API.CALLIOPEDISCOVERY,
+        resource: RESOURCE.CLUSTERS,
+        qs: {
+          JCSupport: 1,
+        },
+      })
+      .then((res) => {
+        const {clusters, joinCookie} = res.body;
 
-      Object.keys(clusters).forEach((key) => {
-        clusters[key].isVideoMesh = res.body.clusterClasses?.hybridMedia?.includes(key);
-      });
+        Object.keys(clusters).forEach((key) => {
+          clusters[key].isVideoMesh = res.body.clusterClasses?.hybridMedia?.includes(key);
+        });
 
-      LoggerProxy.logger.log(`Reachability:request#getClusters --> get clusters successful:${JSON.stringify(clusters)}`);
+        LoggerProxy.logger.log(
+          `Reachability:request#getClusters --> get clusters successful:${JSON.stringify(clusters)}`
+        );
 
-      return clusters;
-    });
+        return {
+          clusters,
+          joinCookie,
+        };
+      });
 
   /**
    * gets remote SDP For Clusters
    * @param {Object} localSDPList localSDPs for the cluster
    * @returns {Object}
    */
-  remoteSDPForClusters = (localSDPList: object) => this.webex.request({
-    method: HTTP_VERBS.POST,
-    shouldRefreshAccessToken: false,
-    api: API.CALLIOPEDISCOVERY,
-    resource: RESOURCE.REACHABILITY,
-    body: {offers: localSDPList}
-  })
-    .then((res) => {
-      LoggerProxy.logger.log('Reachability:request#remoteSDPForClusters --> Remote SDPs got succcessfully');
+  remoteSDPForClusters = (localSDPList: object) =>
+    this.webex
+      .request({
+        method: HTTP_VERBS.POST,
+        shouldRefreshAccessToken: false,
+        api: API.CALLIOPEDISCOVERY,
+        resource: RESOURCE.REACHABILITY,
+        body: {offers: localSDPList},
+      })
+      .then((res) => {
+        LoggerProxy.logger.log(
+          'Reachability:request#remoteSDPForClusters --> Remote SDPs got succcessfully'
+        );
 
-      return res.body;
-    });
+        return res.body;
+      });
 }
 
 export default ReachabilityRequest;

package/src/reactions/constants.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line import/prefer-default-export
+export const REACTION_RELAY_TYPES = {
+  REACTION: 'react',
+} as const;

package/src/reactions/reactions.ts

@@ -0,0 +1,104 @@
+import {Reaction, ReactionServerType, SkinTone, SkinToneType} from './reactions.type';
+
+const Reactions: Record<ReactionServerType, Reaction> = {
+  smile: {
+    type: 'smile',
+    codepoints: '1F642',
+    shortcodes: ':slightly_smiling_face:',
+  },
+  sad: {
+    type: 'sad',
+    codepoints: '1F625',
+    shortcodes: ':sad_but_relieved_face:',
+  },
+  wow: {
+    type: 'wow',
+    codepoints: '1F62E',
+    shortcodes: ':open_mouth:',
+  },
+  haha: {
+    type: 'haha',
+    codepoints: '1F603',
+    shortcodes: ':smiley:',
+  },
+  celebrate: {
+    type: 'celebrate',
+    codepoints: '1F389',
+    shortcodes: ':party_popper:',
+  },
+  clap: {
+    type: 'clap',
+    codepoints: '1F44F',
+    shortcodes: ':clap:',
+  },
+  thumb_up: {
+    type: 'thumb_up',
+    codepoints: '1F44D',
+    shortcodes: ':thumbsup:',
+  },
+  thumb_down: {
+    type: 'thumb_down',
+    codepoints: '1F44E',
+    shortcodes: ':thumbsdown:',
+  },
+  heart: {
+    type: 'heart',
+    codepoints: '2764',
+    shortcodes: ':heart:',
+  },
+  fire: {
+    type: 'fire',
+    codepoints: '1F525',
+    shortcodes: ':fire:',
+  },
+  prayer: {
+    type: 'prayer',
+    codepoints: '1F64F',
+    shortcodes: ':pray:',
+  },
+  speed_up: {
+    type: 'speed_up',
+    codepoints: '1F407',
+    shortcodes: ':rabbit:',
+  },
+  slow_down: {
+    type: 'slow_down',
+    codepoints: '1F422',
+    shortcodes: ':turtle:',
+  },
+};
+
+const SkinTones: Record<SkinToneType, SkinTone> = {
+  normal: {
+    type: 'normal_skin_tone',
+    codepoints: '',
+    shortcodes: '',
+  },
+  light: {
+    type: 'light_skin_tone',
+    codepoints: '1F3FB',
+    shortcodes: ':skin-tone-2:',
+  },
+  medium_light: {
+    type: 'medium_light_skin_tone',
+    codepoints: '1F3FC',
+    shortcodes: ':skin-tone-3:',
+  },
+  medium: {
+    type: 'medium_skin_tone',
+    codepoints: '1F3FD',
+    shortcodes: ':skin-tone-4:',
+  },
+  medium_dark: {
+    type: 'medium_dark_skin_tone',
+    codepoints: '1F3FE',
+    shortcodes: ':skin-tone-5:',
+  },
+  dark: {
+    type: 'dark_skin_tone',
+    codepoints: '1F3FF',
+    shortcodes: ':skin-tone-6:',
+  },
+};
+
+export {Reactions, SkinTones};