@webex/plugin-meetings 2.60.1-next.13 → 2.60.1-next.15

package/src/meeting/voicea-meeting.ts

@@ -15,21 +15,18 @@ export const getSpeakerFromProxyOrStore = ({csisKey, meetingMembers, transcriptD
 
   if (csisKey && transcriptData.speakerProxy[csisKey]) {
     speaker = transcriptData.speakerProxy[csisKey];
+
+    return {speaker, needsCaching};
   }
+
   const meetingMember: any = getSpeaker(meetingMembers, [csisKey]);
 
-  const speakerInStore = {
+  speaker = {
     speakerId: meetingMember?.participant.person.id ?? '',
     name: meetingMember?.participant.person.name ?? '',
   };
 
-  if (
-    meetingMember &&
-    (speakerInStore.speakerId !== speaker.speakerId || speakerInStore.name !== speaker.name)
-  ) {
-    needsCaching = true;
-    speaker = speakerInStore;
-  }
+  needsCaching = true;
 
   return {speaker, needsCaching};
 };
@@ -39,20 +36,16 @@ export const processNewCaptions = ({data, meeting}) => {
   const transcriptData = meeting.transcription;
 
   if (data.isFinal) {
-    const doesInterimTranscriptionExist = transcriptId in transcriptData.interimCaptions;
-
-    if (doesInterimTranscriptionExist) {
-      transcriptData.interimCaptions[transcriptId].forEach((fakeId) => {
-        const fakeTranscriptIndex = transcriptData.captions.findIndex(
-          (transcript) => transcript.id === fakeId
-        );
-
-        if (fakeTranscriptIndex !== -1) {
-          transcriptData.captions.splice(fakeTranscriptIndex, 1);
-        }
-      });
-      delete transcriptData.interimCaptions[transcriptId];
-    }
+    transcriptData.interimCaptions[transcriptId].forEach((interimId) => {
+      const interimTranscriptIndex = transcriptData.captions.findIndex(
+        (transcript) => transcript.id === interimId
+      );
+
+      if (interimTranscriptIndex !== -1) {
+        transcriptData.captions.splice(interimTranscriptIndex, 1);
+      }
+    });
+    delete transcriptData.interimCaptions[transcriptId];
     const csisKey = data.transcript?.csis[0];
 
     const {needsCaching, speaker} = getSpeakerFromProxyOrStore({
@@ -69,7 +62,7 @@ export const processNewCaptions = ({data, meeting}) => {
       isFinal: data.isFinal,
       translations: data.translations,
       text: data.transcript?.text,
-      currentSpokenLanguage: data.transcript?.transcriptLanguageCode,
+      currentSpokenLanguage: data.transcript?.transcript_language_code,
       timestamp: data.timestamp,
       speaker,
     };
@@ -85,12 +78,12 @@ export const processNewCaptions = ({data, meeting}) => {
       csis: [csisMember],
     } = transcript;
 
-    const newCaption = `${transcriptsPerCsis.get(csisMember)?.text ?? ''} ${text}`;
+    const newCaption = `${transcriptsPerCsis.get(csisMember)?.text ?? ''} ${text}`.trim();
 
     // eslint-disable-next-line camelcase
     transcriptsPerCsis.set(csisMember, {text: newCaption, currentSpokenLanguage});
   }
-  const fakeTranscriptionIds = [];
+  const interimTranscriptionIds = [];
 
   for (const [key, value] of transcriptsPerCsis) {
     const {needsCaching, speaker} = getSpeakerFromProxyOrStore({
@@ -103,9 +96,9 @@ export const processNewCaptions = ({data, meeting}) => {
       transcriptData.speakerProxy[key] = speaker;
     }
     const {speakerId} = speaker;
-    const fakeId = `${transcriptId}_${speakerId}`;
+    const interimId = `${transcriptId}_${speakerId}`;
     const captionData = {
-      id: fakeId,
+      id: interimId,
       isFinal: data.isFinal,
       translations: value.translations,
       text: value.text,
@@ -114,48 +107,16 @@ export const processNewCaptions = ({data, meeting}) => {
       speaker,
     };
 
-    const fakeTranscriptIndex = transcriptData.captions.findIndex(
-      (transcript) => transcript.id === fakeId
+    const interimTranscriptIndex = transcriptData.captions.findIndex(
+      (transcript) => transcript.id === interimId
     );
 
-    if (fakeTranscriptIndex !== -1) {
-      transcriptData.captions.splice(fakeTranscriptIndex, 1);
+    if (interimTranscriptIndex !== -1) {
+      transcriptData.captions.splice(interimTranscriptIndex, 1);
     }
 
-    fakeTranscriptionIds.push(fakeId);
+    interimTranscriptionIds.push(interimId);
     transcriptData.captions.push(captionData);
   }
-  transcriptData.interimCaptions[transcriptId] = fakeTranscriptionIds;
-};
-
-export const processHighlightCreated = ({data, meeting}) => {
-  const transcriptData = meeting.transcription;
-
-  if (!transcriptData.highlights) {
-    transcriptData.highlights = [];
-  }
-
-  const csisKey = data.csis && data.csis.length > 0 ? data.csis[0] : undefined;
-  const {needsCaching, speaker} = getSpeakerFromProxyOrStore({
-    meetingMembers: meeting.members.membersCollection.members,
-    transcriptData,
-    csisKey,
-  });
-
-  if (needsCaching) {
-    transcriptData.speakerProxy[csisKey] = speaker;
-  }
-
-  const highlightCreated = {
-    id: data.highlightId,
-    meta: {
-      label: data.highlightLabel,
-      source: data.highlightSource,
-    },
-    text: data.text,
-    timestamp: data.timestamp,
-    speaker,
-  };
-
-  meeting.transcription.highlights.push(highlightCreated);
+  transcriptData.interimCaptions[transcriptId] = interimTranscriptionIds;
 };

package/src/meetings/index.ts

@@ -726,12 +726,20 @@ export default class Meetings extends WebexPlugin {
    * @memberof Meetings
    */
   public register() {
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETINGS_REGISTRATION_STEP, {
+      step: '[sdk] begin registration',
+    });
+
     // @ts-ignore
     if (!this.webex.canAuthorize) {
       LoggerProxy.logger.error(
         'Meetings:index#register --> ERROR, Unable to register, SDK cannot authorize'
       );
 
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETINGS_REGISTRATION_STEP, {
+        step: '[sdk] cannot authorize',
+      });
+
       return Promise.reject(new Error('SDK cannot authorize'));
     }
 
@@ -740,9 +748,17 @@ export default class Meetings extends WebexPlugin {
         'Meetings:index#register --> INFO, Meetings plugin already registered'
       );
 
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETINGS_REGISTRATION_STEP, {
+        step: '[sdk] already registered',
+      });
+
       return Promise.resolve();
     }
 
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETINGS_REGISTRATION_STEP, {
+      step: '[sdk] begin Promise.all()',
+    });
+
     return Promise.all([
       this.fetchUserPreferredWebexSite(),
       this.getGeoHint(),
@@ -764,6 +780,9 @@ export default class Meetings extends WebexPlugin {
       MeetingsUtil.checkH264Support.call(this),
     ])
       .then(() => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETINGS_REGISTRATION_STEP, {
+          step: '[sdk] end Promise.all()',
+        });
         this.listenForEvents();
         Trigger.trigger(
           this,
@@ -773,6 +792,9 @@ export default class Meetings extends WebexPlugin {
           },
           EVENT_TRIGGERS.MEETINGS_REGISTERED
         );
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETINGS_REGISTRATION_STEP, {
+          step: '[sdk] registration complete, triggered MEETINGS_REGISTERED event',
+        });
         this.registered = true;
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETINGS_REGISTRATION_SUCCESS);
       })

package/src/meetings/util.ts

@@ -62,7 +62,7 @@ MeetingsUtil.handleRoapMercury = (envelope, meetingCollection) => {
       if (messageType === ROAP.ROAP_TYPES.TURN_DISCOVERY_RESPONSE) {
         // turn discovery is not part of normal roap protocol and so we are not handling it
         // through the usual roap state machine
-        meeting.roap.turnDiscovery.handleTurnDiscoveryResponse(data.message);
+        meeting.roap.turnDiscovery.handleTurnDiscoveryResponse(data.message, 'from mercury');
       } else {
         const roapMessage = {
           seq,

package/src/metrics/constants.ts

@@ -3,6 +3,7 @@
 const BEHAVIORAL_METRICS = {
   MEETINGS_REGISTRATION_FAILED: 'js_sdk_meetings_registration_failed',
   MEETINGS_REGISTRATION_SUCCESS: 'js_sdk_meetings_registration_success',
+  MEETINGS_REGISTRATION_STEP: 'meetings_registration_step',
   MERCURY_CONNECTION_FAILURE: 'js_sdk_mercury_connection_failure',
   MERCURY_CONNECTION_RESTORED: 'js_sdk_mercury_connection_restored',
   JOIN_SUCCESS: 'js_sdk_join_success',
@@ -67,6 +68,7 @@ const BEHAVIORAL_METRICS = {
   TURN_DISCOVERY_LATENCY: 'js_sdk_turn_discovery_latency',
   ROAP_OFFER_TO_ANSWER_LATENCY: 'js_sdk_roap_offer_to_answer_latency',
   ROAP_HTTP_RESPONSE_MISSING: 'js_sdk_roap_http_response_missing',
+  TURN_DISCOVERY_REQUIRES_OK: 'js_sdk_turn_discovery_requires_ok',
 };
 
 export {BEHAVIORAL_METRICS as default};

package/src/reachability/index.ts

@@ -95,12 +95,6 @@ export default class Reachability {
    * @memberof Reachability
    */
   public async gatherReachability(): Promise<ReachabilityResults> {
-    // 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);
-
     // Fetch clusters and measure latency
     try {
       const {clusters, joinCookie} = await this.reachabilityRequest.getClusters(

package/src/reconnection-manager/index.ts

@@ -349,7 +349,20 @@ export default class ReconnectionManager {
       });
     }
 
-    return this.executeReconnection({networkDisconnect}).catch((reconnectError) => {
+    try {
+      await this.webex.meetings.startReachability();
+    } catch (err) {
+      LoggerProxy.logger.info(
+        'ReconnectionManager:index#reconnect --> Reachability failed, continuing with reconnection attempt, err: ',
+        err
+      );
+    }
+
+    try {
+      const media = await this.executeReconnection({networkDisconnect});
+
+      return media;
+    } catch (reconnectError) {
       if (reconnectError instanceof NeedsRetryError) {
         LoggerProxy.logger.info(
           'ReconnectionManager:index#reconnect --> Reconnection not successful, retrying.'
@@ -370,6 +383,7 @@ export default class ReconnectionManager {
         'ReconnectionManager:index#reconnect --> Sending reconnect abort metric.'
       );
 
+      // send call aborted event with catogery as expected as we are trying to rejoin
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.call.aborted',
@@ -388,16 +402,13 @@ export default class ReconnectionManager {
           meetingId: this.meeting.id,
         },
       });
-      if (reconnectError instanceof NeedsRejoinError) {
-        // send call aborded event with catogery as expected as we are trying to rejoin
 
-        if (this.autoRejoinEnabled) {
-          return this.rejoinMeeting(reconnectError.wasSharing);
-        }
+      if (reconnectError instanceof NeedsRejoinError && this.autoRejoinEnabled) {
+        return this.rejoinMeeting(reconnectError.wasSharing);
       }
 
       throw reconnectError;
-    });
+    }
   }
 
   /**

package/src/roap/turnDiscovery.ts

@@ -56,7 +56,7 @@ export default class TurnDiscovery {
    * @private
    * @memberof Roap
    */
-  private waitForTurnDiscoveryResponse() {
+  private waitForTurnDiscoveryResponse(): Promise<{isOkRequired: boolean}> {
     if (!this.defer) {
       LoggerProxy.logger.warn(
         'Roap:turnDiscovery#waitForTurnDiscoveryResponse --> TURN discovery is not in progress'
@@ -88,22 +88,32 @@ export default class TurnDiscovery {
    * handles TURN_DISCOVERY_RESPONSE roap message
    *
    * @param {Object} roapMessage
+   * @param {string} from string to indicate how we got the response (used just for logging)
    * @returns {void}
    * @public
    * @memberof Roap
    */
-  public handleTurnDiscoveryResponse(roapMessage: object) {
-    // @ts-ignore - Fix missing type
+  public handleTurnDiscoveryResponse(roapMessage: any, from: string) {
     const {headers} = roapMessage;
 
     if (!this.defer) {
       LoggerProxy.logger.warn(
-        'Roap:turnDiscovery#handleTurnDiscoveryResponse --> unexpected TURN discovery response'
+        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> unexpected TURN discovery response ${from}`
       );
 
       return;
     }
 
+    if (roapMessage.messageType !== ROAP.ROAP_TYPES.TURN_DISCOVERY_RESPONSE) {
+      this.defer.reject(
+        new Error(
+          `TURN_DISCOVERY_RESPONSE ${from} has unexpected messageType: ${JSON.stringify(
+            roapMessage
+          )}`
+        )
+      );
+    }
+
     const expectedHeaders = [
       {headerName: 'x-cisco-turn-url', field: 'url'},
       {headerName: 'x-cisco-turn-username', field: 'username'},
@@ -129,21 +139,39 @@ export default class TurnDiscovery {
 
     if (foundHeaders !== expectedHeaders.length) {
       LoggerProxy.logger.warn(
-        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> missing some headers, received: ${JSON.stringify(
+        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> missing some headers, received ${from}: ${JSON.stringify(
           headers
         )}`
       );
       this.defer.reject(
-        new Error(`TURN_DISCOVERY_RESPONSE missing some headers: ${JSON.stringify(headers)}`)
+        new Error(
+          `TURN_DISCOVERY_RESPONSE ${from} missing some headers: ${JSON.stringify(headers)}`
+        )
       );
     } else {
       LoggerProxy.logger.info(
-        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> received a valid response, url=${this.turnInfo.url}`
+        `Roap:turnDiscovery#handleTurnDiscoveryResponse --> received a valid response ${from}, url=${this.turnInfo.url}`
       );
-      this.defer.resolve();
+
+      this.defer.resolve({isOkRequired: !headers?.includes('noOkInTransaction')});
     }
   }
 
+  /**
+   * handles TURN_DISCOVERY_RESPONSE roap message that came in http response
+   *
+   * @param {Object} roapMessage
+   * @returns {Promise}
+   * @memberof Roap
+   */
+  private async handleTurnDiscoveryResponseInHttpResponse(
+    roapMessage: object
+  ): Promise<{isOkRequired: boolean}> {
+    this.handleTurnDiscoveryResponse(roapMessage, 'in http response');
+
+    return this.defer.promise;
+  }
+
   /**
    * sends the TURN_DISCOVERY_REQUEST roap request
    *
@@ -168,6 +196,7 @@ export default class TurnDiscovery {
       messageType: ROAP.ROAP_TYPES.TURN_DISCOVERY_REQUEST,
       version: ROAP.ROAP_VERSION,
       seq: TURN_DISCOVERY_SEQ,
+      headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
     };
 
     LoggerProxy.logger.info(
@@ -186,10 +215,41 @@ export default class TurnDiscovery {
         // @ts-ignore - because of meeting.webex
         ipVersion: MeetingUtil.getIpVersion(meeting.webex),
       })
-      .then(({mediaConnections}) => {
+      .then((response) => {
+        const {mediaConnections} = response;
+
+        let turnDiscoveryResponse;
+
         if (mediaConnections) {
           meeting.updateMediaConnections(mediaConnections);
+
+          if (mediaConnections[0]?.remoteSdp) {
+            const remoteSdp = JSON.parse(mediaConnections[0].remoteSdp);
+
+            if (remoteSdp.roapMessage) {
+              // yes, it's misleading that remoteSdp actually contains a TURN discovery response, but that's how the backend works...
+              const {seq, messageType, errorType, errorCause, headers} = remoteSdp.roapMessage;
+
+              turnDiscoveryResponse = {
+                seq,
+                messageType,
+                errorType,
+                errorCause,
+                headers,
+              };
+            }
+          }
+        }
+
+        if (!turnDiscoveryResponse) {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING, {
+            correlationId: meeting.correlationId,
+            messageType: 'TURN_DISCOVERY_RESPONSE',
+            isMultistream: meeting.isMultistream,
+          });
         }
+
+        return turnDiscoveryResponse;
       });
   }
 
@@ -284,30 +344,46 @@ export default class TurnDiscovery {
       };
     }
 
-    return this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting)
-      .then(() => this.waitForTurnDiscoveryResponse())
-      .then(() => this.sendRoapOK(meeting))
-      .then(() => {
-        this.defer = undefined;
+    try {
+      const httpResponse = await this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting);
 
-        LoggerProxy.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery completed');
+      // if we haven't got the response over http, we need to wait for it to come over the websocket via Mercury
+      const {isOkRequired} = httpResponse
+        ? await this.handleTurnDiscoveryResponseInHttpResponse(httpResponse)
+        : await this.waitForTurnDiscoveryResponse();
+
+      if (isOkRequired) {
+        await this.sendRoapOK(meeting);
 
-        return {turnServerInfo: this.turnInfo, turnDiscoverySkippedReason: undefined};
-      })
-      .catch((e) => {
-        // we catch any errors and resolve with no turn information so that the normal call join flow can continue without TURN
         LoggerProxy.logger.info(
-          `Roap:turnDiscovery#doTurnDiscovery --> TURN discovery failed, continuing without TURN: ${e}`
+          'Roap:turnDiscovery#doTurnDiscovery --> TURN discovery response requires OK'
         );
 
-        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_FAILURE, {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_REQUIRES_OK, {
           correlation_id: meeting.correlationId,
           locus_id: meeting.locusUrl.split('/').pop(),
-          reason: e.message,
-          stack: e.stack,
         });
+      }
 
-        return {turnServerInfo: undefined, turnDiscoverySkippedReason: undefined};
+      this.defer = undefined;
+
+      LoggerProxy.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery completed');
+
+      return {turnServerInfo: this.turnInfo, turnDiscoverySkippedReason: undefined};
+    } catch (e) {
+      // we catch any errors and resolve with no turn information so that the normal call join flow can continue without TURN
+      LoggerProxy.logger.info(
+        `Roap:turnDiscovery#doTurnDiscovery --> TURN discovery failed, continuing without TURN: ${e}`
+      );
+
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_FAILURE, {
+        correlation_id: meeting.correlationId,
+        locus_id: meeting.locusUrl.split('/').pop(),
+        reason: e.message,
+        stack: e.stack,
       });
+
+      return {turnServerInfo: undefined, turnDiscoverySkippedReason: undefined};
+    }
   }
 }

package/src/rtcMetrics/index.ts

@@ -1,7 +1,20 @@
 /* eslint-disable class-methods-use-this */
 import {CallDiagnosticUtils} from '@webex/internal-plugin-metrics';
+import uuid from 'uuid';
 import RTC_METRICS from './constants';
 
+const parseJsonPayload = (payload: any[]): any | null => {
+  try {
+    if (payload && payload[0]) {
+      return JSON.parse(payload[0]);
+    }
+
+    return null;
+  } catch (_) {
+    return null;
+  }
+};
+
 /**
  * Rtc Metrics
  */
@@ -19,6 +32,8 @@ export default class RtcMetrics {
 
   correlationId: string;
 
+  connectionId: string;
+
   /**
    * Initialize the interval.
    *
@@ -32,6 +47,7 @@ export default class RtcMetrics {
     this.meetingId = meetingId;
     this.webex = webex;
     this.correlationId = correlationId;
+    this.setNewConnectionId();
     // Send the first set of metrics at 5 seconds in the case of a user leaving the call shortly after joining.
     setTimeout(this.sendMetricsInQueue.bind(this), 5 * 1000);
   }
@@ -60,7 +76,23 @@ export default class RtcMetrics {
       if (data.name === 'stats-report') {
         data.payload = data.payload.map(this.anonymizeIp);
       }
+
       this.metricsQueue.push(data);
+
+      try {
+        // If a connection fails, send the rest of the metrics in queue and get a new connection id.
+        const parsedPayload = parseJsonPayload(data.payload);
+        if (
+          data.name === 'onconnectionstatechange' &&
+          parsedPayload &&
+          parsedPayload.value === 'failed'
+        ) {
+          this.sendMetricsInQueue();
+          this.setNewConnectionId();
+        }
+      } catch (e) {
+        console.error(e);
+      }
     }
   }
 
@@ -93,6 +125,15 @@ export default class RtcMetrics {
     return JSON.stringify(data);
   }
 
+  /**
+   * Set a new connection id.
+   *
+   * @returns {void}
+   */
+  private setNewConnectionId() {
+    this.connectionId = uuid.v4();
+  }
+
   /**
    * Send metrics to the metrics service.
    *
@@ -111,10 +152,11 @@ export default class RtcMetrics {
         metrics: [
           {
             type: 'webrtc',
-            version: '1.0.1',
+            version: '1.1.0',
             userId: this.webex.internal.device.userId,
             meetingId: this.meetingId,
             correlationId: this.correlationId,
+            connectionId: this.connectionId,
             data: this.metricsQueue,
           },
         ],