@webex/plugin-meetings 2.60.1-next.1 → 2.60.1-next.10

package/src/meeting/request.ts

@@ -185,6 +185,13 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       deviceCapabilities.push(ANNOTATION.ANNOTATION_ON_SHARE_SUPPORTED);
     }
 
+    // append installationId to device config if it exists
+    // @ts-ignore
+    if (this.webex.internal.device.config.installationId) {
+      // @ts-ignore
+      body.device.installationId = this.webex.internal.device.config.installationId;
+    }
+
     if (locale) {
       body.locale = locale;
     }

package/src/meeting/util.ts

@@ -13,6 +13,7 @@ import {
   FULL_STATE,
   SELF_POLICY,
   EVENT_TRIGGERS,
+  LOCAL_SHARE_ERRORS,
   IP_VERSION,
 } from '../constants';
 import BrowserDetection from '../common/browser-detection';
@@ -692,6 +693,102 @@ const MeetingUtil = {
       EVENT_TRIGGERS.MEETING_INTERPRETATION_UPDATE
     );
   },
+
+  /**
+   * Returns a CA-recognized error payload for the specified raw error message/reason.
+   *
+   * New errors can be added to this function for handling in the future
+   *
+   * @param {String} reason the raw error message
+   * @returns {Array<object>} an array of payload objects
+   */
+  getChangeMeetingFloorErrorPayload: (reason: string) => {
+    const errorPayload = {
+      errorDescription: reason,
+      name: 'locus.response',
+      shownToUser: false,
+    };
+    if (reason.includes(LOCAL_SHARE_ERRORS.UNDEFINED)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'signaling',
+          errorCode: 1100,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.DEVICE_NOT_JOINED)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'signaling',
+          errorCode: 4050,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.NO_MEDIA_FOR_DEVICE)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'media',
+          errorCode: 2048,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.NO_CONFLUENCE_ID)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'signaling',
+          errorCode: 4064,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.CONTENT_SHARING_DISABLED)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'expected',
+          errorCode: 4065,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.LOCUS_PARTICIPANT_DNE)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'signaling',
+          errorCode: 4066,
+        },
+      ];
+    }
+    if (reason.includes(LOCAL_SHARE_ERRORS.CONTENT_REQUEST_WHILE_PENDING_WHITEBOARD)) {
+      return [
+        {
+          ...errorPayload,
+          fatal: true,
+          category: 'expected',
+          errorCode: 4067,
+        },
+      ];
+    }
+
+    // return unknown error
+    return [
+      {
+        ...errorPayload,
+        fatal: true,
+        category: 'signaling',
+        errorCode: 1100,
+      },
+    ];
+  },
 };
 
 export default MeetingUtil;

package/src/meeting/voicea-meeting.ts

@@ -0,0 +1,161 @@
+export const getSpeaker = (members, csis = []) =>
+  Object.values(members).find((member: any) => {
+    const memberCSIs = member.participant.status.csis ?? [];
+
+    return csis.some((csi) => memberCSIs.includes(csi));
+  });
+
+export const getSpeakerFromProxyOrStore = ({csisKey, meetingMembers, transcriptData}) => {
+  let speaker = {
+    speakerId: '',
+    name: '',
+  };
+
+  let needsCaching = false;
+
+  if (csisKey && transcriptData.speakerProxy[csisKey]) {
+    speaker = transcriptData.speakerProxy[csisKey];
+  }
+  const meetingMember: any = getSpeaker(meetingMembers, [csisKey]);
+
+  const speakerInStore = {
+    speakerId: meetingMember?.participant.person.id ?? '',
+    name: meetingMember?.participant.person.name ?? '',
+  };
+
+  if (
+    meetingMember &&
+    (speakerInStore.speakerId !== speaker.speakerId || speakerInStore.name !== speaker.name)
+  ) {
+    needsCaching = true;
+    speaker = speakerInStore;
+  }
+
+  return {speaker, needsCaching};
+};
+
+export const processNewCaptions = ({data, meeting}) => {
+  const {transcriptId} = data;
+  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];
+    }
+    const csisKey = data.transcript?.csis[0];
+
+    const {needsCaching, speaker} = getSpeakerFromProxyOrStore({
+      meetingMembers: meeting.members.membersCollection.members,
+      transcriptData,
+      csisKey,
+    });
+
+    if (needsCaching) {
+      transcriptData.speakerProxy[csisKey] = speaker;
+    }
+    const captionData = {
+      id: transcriptId,
+      isFinal: data.isFinal,
+      translations: data.translations,
+      text: data.transcript?.text,
+      currentSpokenLanguage: data.transcript?.transcriptLanguageCode,
+      timestamp: data.timestamp,
+      speaker,
+    };
+    transcriptData.captions.push(captionData);
+  }
+  const {transcripts = []} = data;
+  const transcriptsPerCsis = new Map();
+
+  for (const transcript of transcripts) {
+    const {
+      text,
+      transcript_language_code: currentSpokenLanguage,
+      csis: [csisMember],
+    } = transcript;
+
+    const newCaption = `${transcriptsPerCsis.get(csisMember)?.text ?? ''} ${text}`;
+
+    // eslint-disable-next-line camelcase
+    transcriptsPerCsis.set(csisMember, {text: newCaption, currentSpokenLanguage});
+  }
+  const fakeTranscriptionIds = [];
+
+  for (const [key, value] of transcriptsPerCsis) {
+    const {needsCaching, speaker} = getSpeakerFromProxyOrStore({
+      meetingMembers: meeting.members.membersCollection.members,
+      transcriptData,
+      csisKey: key,
+    });
+
+    if (needsCaching) {
+      transcriptData.speakerProxy[key] = speaker;
+    }
+    const {speakerId} = speaker;
+    const fakeId = `${transcriptId}_${speakerId}`;
+    const captionData = {
+      id: fakeId,
+      isFinal: data.isFinal,
+      translations: value.translations,
+      text: value.text,
+      currentCaptionLanguage: value.currentSpokenLanguage,
+      timestamp: value?.timestamp,
+      speaker,
+    };
+
+    const fakeTranscriptIndex = transcriptData.captions.findIndex(
+      (transcript) => transcript.id === fakeId
+    );
+
+    if (fakeTranscriptIndex !== -1) {
+      transcriptData.captions.splice(fakeTranscriptIndex, 1);
+    }
+
+    fakeTranscriptionIds.push(fakeId);
+    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);
+};

package/src/meetings/index.ts

@@ -584,7 +584,7 @@ export default class Meetings extends WebexPlugin {
 
     // @ts-ignore
     this.webex.internal.mercury.on(ONLINE, () => {
-      this.syncMeetings();
+      this.syncMeetings({keepOnlyLocusMeetings: false});
     });
 
     // @ts-ignore
@@ -699,6 +699,24 @@ export default class Meetings extends WebexPlugin {
     }
   }
 
+  /**
+   * API to toggle TCP reachability, needs to be called before webex.meetings.register()
+   * @param {Boolean} newValue
+   * @private
+   * @memberof Meetings
+   * @returns {undefined}
+   */
+  private _toggleTcpReachability(newValue: boolean) {
+    if (typeof newValue !== 'boolean') {
+      return;
+    }
+    // @ts-ignore
+    if (this.config.experimental.enableTcpReachability !== newValue) {
+      // @ts-ignore
+      this.config.experimental.enableTcpReachability = newValue;
+    }
+  }
+
   /**
    * Explicitly sets up the meetings plugin by registering
    * the device, connecting to mercury, and listening for locus events.
@@ -1026,6 +1044,9 @@ export default class Meetings extends WebexPlugin {
 
   /**
    * Create a meeting or return an existing meeting.
+   *
+   * When meeting info passed it should be complete, e.g.: fetched after password or captcha provided
+   *
    * @param {string} destination - sipURL, phonenumber, or locus object}
    * @param {string} [type] - the optional specified type, such as locusId
    * @param {Boolean} useRandomDelayForInfo - whether a random delay should be added to fetching meeting info
@@ -1033,6 +1054,8 @@ export default class Meetings extends WebexPlugin {
    * @param {string} correlationId - the optional specified correlationId (callStateForMetrics.correlationId can be provided instead)
    * @param {Boolean} failOnMissingMeetingInfo - whether to throw an error if meeting info fails to fetch (for calls that are not 1:1 or content share)
    * @param {CallStateForMetrics} callStateForMetrics - information about call state for metrics
+   * @param {Object} [meetingInfo] - Pre-fetched complete meeting info
+   * @param {String} [meetingLookupUrl] - meeting info prefetch url
    * @returns {Promise<Meeting>} A new Meeting.
    * @public
    * @memberof Meetings
@@ -1044,7 +1067,9 @@ export default class Meetings extends WebexPlugin {
     infoExtraParams = {},
     correlationId: string = undefined,
     failOnMissingMeetingInfo = false,
-    callStateForMetrics: CallStateForMetrics = undefined
+    callStateForMetrics: CallStateForMetrics = undefined,
+    meetingInfo = undefined,
+    meetingLookupUrl = undefined
   ) {
     // TODO: type should be from a dictionary
 
@@ -1103,7 +1128,9 @@ export default class Meetings extends WebexPlugin {
               useRandomDelayForInfo,
               infoExtraParams,
               callStateForMetrics,
-              failOnMissingMeetingInfo
+              failOnMissingMeetingInfo,
+              meetingInfo,
+              meetingLookupUrl
             ).then((createdMeeting: any) => {
               // If the meeting was successfully created.
               if (createdMeeting && createdMeeting.on) {
@@ -1158,12 +1185,18 @@ export default class Meetings extends WebexPlugin {
   }
 
   /**
+   * Create meeting
+   *
+   * When meeting info passed it should be complete, e.g.: fetched after password or captcha provided
+   *
    * @param {String} destination see create()
    * @param {String} type see create()
    * @param {Boolean} useRandomDelayForInfo whether a random delay should be added to fetching meeting info
    * @param {Object} infoExtraParams extra parameters to be provided when fetching meeting info
    * @param {CallStateForMetrics} callStateForMetrics - information about call state for metrics
    * @param {Boolean} failOnMissingMeetingInfo - whether to throw an error if meeting info fails to fetch (for calls that are not 1:1 or content share)
+   * @param {Object} [meetingInfo] - Pre-fetched complete meeting info
+   * @param {String} [meetingLookupUrl] - meeting info prefetch url
    * @returns {Promise} a new meeting instance complete with meeting info and destination
    * @private
    * @memberof Meetings
@@ -1174,7 +1207,9 @@ export default class Meetings extends WebexPlugin {
     useRandomDelayForInfo = false,
     infoExtraParams = {},
     callStateForMetrics: CallStateForMetrics = undefined,
-    failOnMissingMeetingInfo = false
+    failOnMissingMeetingInfo = false,
+    meetingInfo = undefined,
+    meetingLookupUrl = undefined
   ) {
     const meeting = new Meeting(
       {
@@ -1220,22 +1255,26 @@ export default class Meetings extends WebexPlugin {
       const isMeetingActive = !!destination.fullState?.active;
       // @ts-ignore
       const {enableUnifiedMeetings} = this.config.experimental;
-
-      if (enableUnifiedMeetings && !isMeetingActive && useRandomDelayForInfo && waitingTime > 0) {
+      const meetingInfoOptions = {
+        extraParams: infoExtraParams,
+        sendCAevents: !!callStateForMetrics?.correlationId, // if client sends correlation id as argument of public create(), then it means that this meeting creation is part of a pre-join intent from user
+      };
+
+      if (meetingInfo) {
+        meeting.injectMeetingInfo(meetingInfo, meetingInfoOptions, meetingLookupUrl);
+      } else if (
+        enableUnifiedMeetings &&
+        !isMeetingActive &&
+        useRandomDelayForInfo &&
+        waitingTime > 0
+      ) {
         meeting.fetchMeetingInfoTimeoutId = setTimeout(
-          () =>
-            meeting.fetchMeetingInfo({
-              extraParams: infoExtraParams,
-              sendCAevents: !!callStateForMetrics?.correlationId, // if client sends correlation id as argument of public create(), then it means that this meeting creation is part of a pre-join intent from user
-            }),
+          () => meeting.fetchMeetingInfo(meetingInfoOptions),
           waitingTime
         );
         meeting.parseMeetingInfo(undefined, destination);
       } else {
-        await meeting.fetchMeetingInfo({
-          extraParams: infoExtraParams,
-          sendCAevents: !!callStateForMetrics?.correlationId, // if client sends correlation id as argument of public create(), then it means that this meeting creation is part of a pre-join intent from user
-        });
+        await meeting.fetchMeetingInfo(meetingInfoOptions);
       }
     } catch (err) {
       if (
@@ -1346,11 +1385,12 @@ export default class Meetings extends WebexPlugin {
 
   /**
    * syncs all the meeting from server
-   * @returns {undefined}
+   * @param {boolean} keepOnlyLocusMeetings - whether the sync should keep only locus meetings or any other meeting in meetingCollection
+   * @returns {Promise<void>}
    * @public
    * @memberof Meetings
    */
-  public syncMeetings() {
+  public syncMeetings({keepOnlyLocusMeetings = true} = {}): Promise<void> {
     return this.request
       .getActiveMeetings()
       .then((locusArray) => {
@@ -1374,7 +1414,8 @@ export default class Meetings extends WebexPlugin {
           // (they had a locusUrl previously but are no longer active) in the sync
           for (const meeting of Object.values(meetingsCollection)) {
             // @ts-ignore
-            if (meeting.locusUrl && !activeLocusUrl.includes(meeting.locusUrl)) {
+            const {locusUrl} = meeting;
+            if ((keepOnlyLocusMeetings || locusUrl) && !activeLocusUrl.includes(locusUrl)) {
               // destroy function also uploads logs
               // @ts-ignore
               this.destroy(meeting, MEETING_REMOVED_REASON.NO_MEETINGS_TO_SYNC);

package/src/reachability/index.ts

@@ -341,18 +341,21 @@ export default class Reachability {
       return Promise.resolve(results);
     }
 
-    // @ts-ignore
-    const includeTcpReachability = this.webex.config.meetings.experimental.enableTcpReachability;
-
     LoggerProxy.logger.log(
       `Reachability:index#performReachabilityChecks --> doing UDP${
-        includeTcpReachability ? ' and TCP' : ''
+        // @ts-ignore
+        this.webex.config.meetings.experimental.enableTcpReachability ? ' and TCP' : ''
       } reachability checks`
     );
 
     const clusterReachabilityChecks = Object.keys(clusterList).map((key) => {
       const cluster = clusterList[key];
 
+      // Linus doesn't support TCP reachability checks on video mesh nodes
+      const includeTcpReachability =
+        // @ts-ignore
+        this.webex.config.meetings.experimental.enableTcpReachability && !cluster.isVideoMesh;
+
       if (!includeTcpReachability) {
         cluster.tcp = [];
       }

package/src/reconnection-manager/index.ts

@@ -442,7 +442,7 @@ export default class ReconnectionManager {
         LoggerProxy.logger.info(
           'ReconnectionManager:index#executeReconnection --> Updating meeting data from server.'
         );
-        await this.webex.meetings.syncMeetings();
+        await this.webex.meetings.syncMeetings({keepOnlyLocusMeetings: false});
       } catch (syncError) {
         LoggerProxy.logger.info(
           'ReconnectionManager:index#executeReconnection --> Unable to sync meetings, reconnecting.',

package/src/roap/index.ts

@@ -187,7 +187,7 @@ export default class Roap extends StatelessWebexPlugin {
    * @memberof Roap
    */
   sendRoapMediaRequest(options: any) {
-    const {meeting, seq, sdp, reconnect, tieBreaker} = options;
+    const {meeting, seq, sdp, tieBreaker} = options;
     const roapMessage = {
       messageType: ROAP.ROAP_TYPES.OFFER,
       sdps: [sdp],
@@ -197,64 +197,62 @@ export default class Roap extends StatelessWebexPlugin {
       headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
     };
 
-    // When reconnecting, it's important that the first roap message being sent out has empty media id.
-    // Normally this is the roap offer, but when TURN discovery is enabled,
-    // then this is the TURN discovery request message
-    return this.turnDiscovery.isSkipped(meeting).then((isTurnDiscoverySkipped) => {
-      const sendEmptyMediaId = reconnect && isTurnDiscoverySkipped;
+    // The only time we want to send an empty media id is when we are reconnecting, because this way we tell Locus
+    // that it needs to create a new confluence, but when reconnecting we always send TURN_DISCOVERY_REQUEST first,
+    // so we don't need to ever send an empty media id here
+    const sendEmptyMediaId = false;
 
-      return this.roapRequest
-        .sendRoap({
-          roapMessage,
-          locusSelfUrl: meeting.selfUrl,
-          mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
-          meetingId: meeting.id,
-          preferTranscoding: !meeting.isMultistream,
-          locusMediaRequest: meeting.locusMediaRequest,
-          ipVersion: MeetingUtil.getIpVersion(meeting.webex),
-        })
-        .then(({locus, mediaConnections}) => {
-          if (mediaConnections) {
-            meeting.updateMediaConnections(mediaConnections);
-          }
+    return this.roapRequest
+      .sendRoap({
+        roapMessage,
+        locusSelfUrl: meeting.selfUrl,
+        mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
+        meetingId: meeting.id,
+        preferTranscoding: !meeting.isMultistream,
+        locusMediaRequest: meeting.locusMediaRequest,
+        ipVersion: MeetingUtil.getIpVersion(meeting.webex),
+      })
+      .then(({locus, mediaConnections}) => {
+        if (mediaConnections) {
+          meeting.updateMediaConnections(mediaConnections);
+        }
 
-          let roapAnswer;
+        let roapAnswer;
 
-          if (mediaConnections?.[0]?.remoteSdp) {
-            const remoteSdp = JSON.parse(mediaConnections[0].remoteSdp);
+        if (mediaConnections?.[0]?.remoteSdp) {
+          const remoteSdp = JSON.parse(mediaConnections[0].remoteSdp);
 
-            if (remoteSdp.roapMessage) {
-              const {
-                seq: answerSeq,
-                messageType,
-                sdps,
-                errorType,
-                errorCause,
-                headers,
-              } = remoteSdp.roapMessage;
+          if (remoteSdp.roapMessage) {
+            const {
+              seq: answerSeq,
+              messageType,
+              sdps,
+              errorType,
+              errorCause,
+              headers,
+            } = remoteSdp.roapMessage;
 
-              roapAnswer = {
-                seq: answerSeq,
-                messageType,
-                sdp: sdps[0],
-                errorType,
-                errorCause,
-                headers,
-              };
-            }
+            roapAnswer = {
+              seq: answerSeq,
+              messageType,
+              sdp: sdps[0],
+              errorType,
+              errorCause,
+              headers,
+            };
           }
+        }
 
-          if (!roapAnswer) {
-            Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING, {
-              correlationId: meeting.correlationId,
-              messageType: 'ANSWER',
-              isMultistream: meeting.isMultistream,
-            });
-          }
+        if (!roapAnswer) {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING, {
+            correlationId: meeting.correlationId,
+            messageType: 'ANSWER',
+            isMultistream: meeting.isMultistream,
+          });
+        }
 
-          return {locus, roapAnswer};
-        });
-    });
+        return {locus, roapAnswer};
+      });
   }
 
   /**

package/src/statsAnalyzer/index.ts

@@ -7,7 +7,7 @@ import EventsScope from '../common/events/events-scope';
 import {
   DEFAULT_GET_STATS_FILTER,
   STATS,
-  MQA_INTEVAL,
+  MQA_INTERVAL,
   NETWORK_TYPE,
   MEDIA_DEVICES,
   _UNKNOWN_,
@@ -299,7 +299,7 @@ export class StatsAnalyzer extends EventsScope {
         this.sendMqaData();
         this.mqaInterval = setInterval(() => {
           this.sendMqaData();
-        }, MQA_INTEVAL);
+        }, MQA_INTERVAL);
       });
     }