@webex/plugin-meetings 3.0.0-stream-classes.5 → 3.0.0

package/src/meeting/request.ts

@@ -4,6 +4,7 @@ import {debounce} from 'lodash';
 import {StatelessWebexPlugin} from '@webex/webex-core';
 // @ts-ignore
 import {deviceType} from '@webex/common';
+import {CallDiagnosticUtils} from '@webex/internal-plugin-metrics';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import {
@@ -184,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;
     }
@@ -198,6 +206,10 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       body.device.countryCode = this.webex.meetings.geoHintInfo.countryCode;
       // @ts-ignore
       body.device.regionCode = this.webex.meetings.geoHintInfo.regionCode;
+      body.device.localIp =
+        // @ts-ignore
+        CallDiagnosticUtils.anonymizeIPAddress(this.webex.meetings.geoHintInfo.clientAddress) ||
+        undefined;
     }
 
     if (moderator !== undefined) {
@@ -641,6 +653,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @param {String} options.deviceUrl Url of a device
    * @param {String} options.resourceId Populated if you are paired to a device
    * @param {String} options.uri floor grant uri
+   * @param {String} options.shareInstanceId id for current share
    * @returns {Promise}
    */
   changeMeetingFloor(
@@ -652,6 +665,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
           resourceId: string;
           uri: string;
           annotationInfo: AnnotationInfo;
+          shareInstanceId: string;
         }
       | any
   ) {
@@ -682,6 +696,10 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       resourceUrl: options.resourceUrl,
     };
 
+    if (options?.shareInstanceId) {
+      body.floor.shareInstanceId = options.shareInstanceId;
+    }
+
     if (options?.resourceToken) {
       body.resourceToken = options?.resourceToken;
     }

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';
@@ -201,7 +202,11 @@ const MeetingUtil = {
         meeting.reconnectionManager.cleanUp();
       })
       .then(() => meeting.stopKeepAlive())
-      .then(() => meeting.updateLLMConnection());
+      .then(() => {
+        if (meeting.config?.enableAutomaticLLM) {
+          meeting.updateLLMConnection();
+        }
+      });
   },
 
   disconnectPhoneAudio: (meeting, phoneUrl) => {
@@ -692,6 +697,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,122 @@
+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];
+
+    return {speaker, needsCaching};
+  }
+
+  const meetingMember: any = getSpeaker(meetingMembers, [csisKey]);
+
+  speaker = {
+    speakerId: meetingMember?.participant.person.id ?? '',
+    name: meetingMember?.participant.person.name ?? '',
+  };
+
+  needsCaching = true;
+
+  return {speaker, needsCaching};
+};
+
+export const processNewCaptions = ({data, meeting}) => {
+  const {transcriptId} = data;
+  const transcriptData = meeting.transcription;
+
+  if (data.isFinal) {
+    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({
+      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?.transcript_language_code,
+      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}`.trim();
+
+    // eslint-disable-next-line camelcase
+    transcriptsPerCsis.set(csisMember, {text: newCaption, currentSpokenLanguage});
+  }
+  const interimTranscriptionIds = [];
+
+  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 interimId = `${transcriptId}_${speakerId}`;
+    const captionData = {
+      id: interimId,
+      isFinal: data.isFinal,
+      translations: value.translations,
+      text: value.text,
+      currentCaptionLanguage: value.currentSpokenLanguage,
+      timestamp: value?.timestamp,
+      speaker,
+    };
+
+    const interimTranscriptIndex = transcriptData.captions.findIndex(
+      (transcript) => transcript.id === interimId
+    );
+
+    if (interimTranscriptIndex !== -1) {
+      transcriptData.captions.splice(interimTranscriptIndex, 1);
+    }
+
+    interimTranscriptionIds.push(interimId);
+    transcriptData.captions.push(captionData);
+  }
+  transcriptData.interimCaptions[transcriptId] = interimTranscriptionIds;
+};

package/src/meeting-info/index.ts

@@ -71,20 +71,39 @@ export default class MeetingInfo {
    * @memberof MeetingInfo
    */
   private requestFetchInfo(options: any) {
-    const {meetingId} = options;
-    if (meetingId) {
+    const {meetingId, sendCAevents} = options;
+    if (meetingId && sendCAevents) {
       this.webex.internal.newMetrics.submitInternalEvent({
         name: 'internal.client.meetinginfo.request',
       });
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.meetinginfo.request',
+        options: {
+          meetingId,
+        },
+      });
     }
 
     return this.meetingInfoRequest
       .fetchMeetingInfo(options)
       .then((info) => {
-        if (meetingId) {
+        if (meetingId && sendCAevents) {
           this.webex.internal.newMetrics.submitInternalEvent({
             name: 'internal.client.meetinginfo.response',
           });
+          this.webex.internal.newMetrics.submitClientEvent({
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: info?.url,
+              },
+            },
+            options: {
+              meetingId,
+              webexConferenceIdStr: info?.body?.confIdStr || info?.body?.confID,
+              globalMeetingId: info?.body?.meetingId,
+            },
+          });
         }
         if (info && info.body) {
           this.setMeetingInfo(info.body.sipMeetingUri || info.body.meetingLink, info.body);
@@ -96,21 +115,23 @@ export default class MeetingInfo {
         LoggerProxy.logger.error(
           `Meeting-info:index#requestFetchInfo -->  ${error} fetch meetingInfo`
         );
-        this.webex.internal.newMetrics.submitInternalEvent({
-          name: 'internal.client.meetinginfo.response',
-        });
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.meetinginfo.response',
-          payload: {
-            identifiers: {
-              meetingLookupUrl: error?.url,
+        if (meetingId && sendCAevents) {
+          this.webex.internal.newMetrics.submitInternalEvent({
+            name: 'internal.client.meetinginfo.response',
+          });
+          this.webex.internal.newMetrics.submitClientEvent({
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: error?.url,
+              },
+            },
+            options: {
+              meetingId,
+              rawError: error,
             },
-          },
-          options: {
-            meetingId,
-            rawError: error,
-          },
-        });
+          });
+        }
 
         return Promise.reject(error);
       });
@@ -137,6 +158,12 @@ export default class MeetingInfo {
    * Fetches meeting info from the server
    * @param {String} destination one of many different types of destinations to look up info for
    * @param {String} [type] to match up with the destination value
+   * @param {String} [password] meeting password
+   * @param {Object} [captchaInfo] captcha code and id
+   * @param {String} [installedOrgID]
+   * @param {String} [locusId]
+   * @param {Object} [extraParams]
+   * @param {Boolean} [options] meeting Id and whether Call Analyzer events should be sent
    * @returns {Promise} returns a meeting info object
    * @public
    * @memberof MeetingInfo
@@ -157,7 +184,7 @@ export default class MeetingInfo {
     locusId = null,
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     extraParams: object = {},
-    options: {meetingId?: string} = {}
+    options: {meetingId?: string; sendCAevents?: boolean} = {}
   ) {
     if (type === _PERSONAL_ROOM_ && !destination) {
       destination = this.webex.internal.device.userId;
@@ -166,13 +193,13 @@ export default class MeetingInfo {
     return this.fetchInfoOptions(MeetingInfoUtil.extractDestination(destination, type), type).then(
       (infoOptions) =>
         // fetch meeting info
-        this.requestFetchInfo({...infoOptions, meetingId: options.meetingId}).catch((error) => {
+        this.requestFetchInfo({...infoOptions, ...options}).catch((error) => {
           // if it failed the first time as meeting link
           if (infoOptions.type === _MEETING_LINK_) {
             // convert the meeting link to sip URI and retry
             return this.requestFetchInfo({
               ...this.fetchInfoOptions(MeetingInfoUtil.convertLinkToSip(destination), _SIP_URI_),
-              meetingId: options.meetingId,
+              ...options,
             });
           }
 

package/src/meeting-info/meeting-info-v2.ts

@@ -204,22 +204,16 @@ export default class MeetingInfoV2 {
       return invitees;
     };
 
-    return this.webex.internal.conversation
-      .get({url: conversationUrl}, {includeParticipants: true, disableTransform: true})
-      .then((conversation) => {
-        const body: {
-          title: string;
-          spaceUrl: string;
-          keyUrl: string;
-          kroUrl: string;
-          invitees: any[];
-          installedOrgID?: string;
-        } = {
+    return this.webex
+      .request({uri: conversationUrl, qs: {includeParticipants: true}, disableTransform: true})
+      .then(({body: conversation}) => {
+        const body = {
           title: conversation.displayName,
           spaceUrl: conversation.url,
           keyUrl: conversation.encryptionKeyUrl,
           kroUrl: conversation.kmsResourceObjectUrl,
           invitees: getInvitees(conversation.participants?.items),
+          installedOrgID,
         };
 
         if (installedOrgID) {
@@ -279,9 +273,9 @@ export default class MeetingInfoV2 {
     installedOrgID = null,
     locusId = null,
     extraParams: object = {},
-    options: {meetingId?: string} = {}
+    options: {meetingId?: string; sendCAevents?: boolean} = {}
   ) {
-    const {meetingId} = options;
+    const {meetingId, sendCAevents} = options;
 
     const destinationType = await MeetingInfoUtil.getDestinationType({
       destination,
@@ -336,29 +330,51 @@ export default class MeetingInfoV2 {
       requestOptions.resource = 'meetingInfo';
     }
 
-    if (meetingId) {
+    if (meetingId && sendCAevents) {
       this.webex.internal.newMetrics.submitInternalEvent({
         name: 'internal.client.meetinginfo.request',
       });
+
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.meetinginfo.request',
+        options: {
+          meetingId,
+        },
+      });
     }
 
     return this.webex
       .request(requestOptions)
       .then((response) => {
-        if (meetingId) {
+        if (meetingId && sendCAevents) {
           this.webex.internal.newMetrics.submitInternalEvent({
             name: 'internal.client.meetinginfo.response',
           });
+
+          this.webex.internal.newMetrics.submitClientEvent({
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: response?.url,
+              },
+            },
+            options: {
+              meetingId,
+              webexConferenceIdStr: response?.body?.confIdStr || response?.body?.confID,
+              globalMeetingId: response?.body?.meetingId,
+            },
+          });
         }
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_SUCCESS);
 
         return response;
       })
       .catch((err) => {
-        if (meetingId) {
+        if (meetingId && sendCAevents) {
           this.webex.internal.newMetrics.submitInternalEvent({
             name: 'internal.client.meetinginfo.response',
           });
+
           this.webex.internal.newMetrics.submitClientEvent({
             name: 'client.meetinginfo.response',
             payload: {

package/src/meeting-info/util.ts

@@ -1,13 +1,12 @@
 import url from 'url';
 
 import btoa from 'btoa';
-import {
-  // @ts-ignore
-  deconstructHydraId,
-} from '@webex/common';
+// @ts-ignore
+import {deconstructHydraId} from '@webex/common';
 
 import ParameterError from '../common/errors/parameter';
 import LoggerProxy from '../common/logs/logger-proxy';
+
 import {
   _SIP_URI_,
   _PERSONAL_ROOM_,
@@ -221,12 +220,16 @@ MeetingInfoUtil.generateOptions = async (from) => {
     try {
       await webex.internal.services.waitForCatalog('postauth');
 
-      const conversationUrl = webex.internal.conversation.getUrlFromClusterId({
-        cluster: hydraId.cluster,
-        id: hydraId.destination,
-      });
+      const serviceUrl = webex.internal.services.getServiceUrlFromClusterId(
+        {
+          cluster: hydraId.cluster,
+        },
+        webex
+      );
 
-      options.destination = conversationUrl;
+      options.destination = hydraId.destination
+        ? `${serviceUrl}/conversations/${hydraId.destination}`
+        : serviceUrl;
     } catch (e) {
       LoggerProxy.logger.error(`Meeting-info:util#generateOptions --> ${e}`);
       throw e;

package/src/meeting-info/utilv2.ts

@@ -1,9 +1,7 @@
 import url from 'url';
 
-import {
-  // @ts-ignore
-  deconstructHydraId,
-} from '@webex/common';
+// @ts-ignore
+import {deconstructHydraId} from '@webex/common';
 
 import {
   _SIP_URI_,
@@ -21,6 +19,8 @@ import {
   JOIN,
   MEET,
   MEET_M,
+  MEET_CISCO,
+  MEET_CO,
   HTTPS_PROTOCOL,
   UUID_REG,
   VALID_EMAIL_ADDRESS,
@@ -68,6 +68,8 @@ MeetingInfoUtil.isMeetingLink = (value: string) => {
     parsedUrl.pathname &&
     (parsedUrl.pathname.includes(`/${MEET}`) ||
       parsedUrl.pathname.includes(`/${MEET_M}`) ||
+      parsedUrl.pathname.includes(`/${MEET_CISCO}`) ||
+      parsedUrl.pathname.includes(`/${MEET_CO}`) ||
       parsedUrl.pathname.includes(`/${JOIN}`));
 
   return hostNameBool && pathNameBool;
@@ -162,7 +164,13 @@ MeetingInfoUtil.getDestinationType = async (from) => {
     };
   }
   const options: any = {};
-  const hydraId = MeetingInfoUtil.getHydraId(destination);
+  let hydraId;
+
+  if (webex && webex.config && webex.config.meetings && webex.config.meetings.disableHydraId) {
+    hydraId = null;
+  } else {
+    hydraId = MeetingInfoUtil.getHydraId(destination);
+  }
 
   if (MeetingInfoUtil.isMeetingLink(destination)) {
     LoggerProxy.logger.warn(
@@ -180,22 +188,24 @@ MeetingInfoUtil.getDestinationType = async (from) => {
   } else if (MeetingInfoUtil.isConversationUrl(destination, webex)) {
     options.type = _CONVERSATION_URL_;
     options.destination = destination;
-  } else if (hydraId.people) {
+  } else if (hydraId && hydraId.people) {
     options.type = _SIP_URI_;
 
-    return MeetingInfoUtil.getSipUriFromHydraPersonId(hydraId.destination, webex).then((res) => {
-      options.destination = res;
+    return MeetingInfoUtil.getSipUriFromHydraPersonId(hydraId && hydraId.destination, webex).then(
+      (res) => {
+        options.destination = res;
 
-      // Since hydra person ids require a unique case in which they are
-      // entirely converted to a SIP URI, we need to set a flag for detecting
-      // this type of destination.
-      options.wasHydraPerson = true;
+        // Since hydra person ids require a unique case in which they are
+        // entirely converted to a SIP URI, we need to set a flag for detecting
+        // this type of destination.
+        options.wasHydraPerson = true;
 
-      return Promise.resolve(options);
-    });
+        return Promise.resolve(options);
+      }
+    );
   } else if (hydraId.room) {
     LoggerProxy.logger.error(
-      `Meeting-info:util#getDestinationType --> Using the space ID as a destination is no longer supported. Please refer to the [migration guide](https://github.com/webex/webex-js-sdk/wiki/Migration-guide-for-USM-meeting) to migrate to use the meeting ID or SIP address.`
+      `Meeting-info:util#getDestinationType --> Using the space ID as a destination is no longer supported. Please refer to the [migration guide](https://github.com/webex/webex-js-sdk/wiki/Migration-to-Unified-Space-Meetings) to migrate to use the meeting ID or SIP address.`
     );
     // Error code 30105 added as Space ID deprecated as of beta, Please refer migration guide.
     throw new SpaceIDDeprecatedError();

package/src/meetings/collection.ts

@@ -60,4 +60,17 @@ export default class MeetingCollection extends Collection {
 
     return null;
   }
+
+  /**
+   * Gets the meeting that has a webrtc media connection
+   * NOTE: this function assumes there is no more than 1 such meeting
+   *
+   * @returns {Meeting} first meeting found, else undefined
+   * @public
+   * @memberof MeetingCollection
+   */
+  public getActiveWebrtcMeeting() {
+    // @ts-ignore
+    return find(this.meetings, (meeting) => meeting.mediaProperties.webrtcMediaConnection);
+  }
 }