@webex/plugin-meetings 3.0.0-stream-classes.4 → 3.0.0-test.1

package/src/meeting/muteState.ts

@@ -150,15 +150,30 @@ export class MuteState {
    * @param {Boolean} [mute] true for muting, false for unmuting request
    * @returns {void}
    */
-  public handleLocalStreamMuteStateChange(meeting?: object, mute?: boolean) {
+  public handleLocalStreamMuteStateChange(meeting?: any) {
     if (this.ignoreMuteStateChange) {
       return;
     }
+
+    // either user or system may have triggered a mute state change, but localMute should reflect both
+    let newMuteState: boolean;
+    let userMuteState: boolean;
+    let systemMuteState: boolean;
+    if (this.type === AUDIO) {
+      newMuteState = meeting.mediaProperties.audioStream?.muted;
+      userMuteState = meeting.mediaProperties.audioStream?.userMuted;
+      systemMuteState = meeting.mediaProperties.audioStream?.systemMuted;
+    } else {
+      newMuteState = meeting.mediaProperties.videoStream?.muted;
+      userMuteState = meeting.mediaProperties.videoStream?.userMuted;
+      systemMuteState = meeting.mediaProperties.videoStream?.systemMuted;
+    }
+
     LoggerProxy.logger.info(
-      `Meeting:muteState#handleLocalStreamMuteStateChange --> ${this.type}: local stream new mute state: ${mute}`
+      `Meeting:muteState#handleLocalStreamMuteStateChange --> ${this.type}: local stream new mute state: ${newMuteState} (user mute: ${userMuteState}, system mute: ${systemMuteState})`
     );
 
-    this.state.client.localMute = mute;
+    this.state.client.localMute = newMuteState;
 
     this.applyClientStateToServer(meeting);
   }
@@ -249,7 +264,12 @@ export class MuteState {
           `Meeting:muteState#applyClientStateToServer --> ${this.type}: error: ${e}`
         );
 
-        this.applyServerMuteToLocalStream(meeting, 'clientRequestFailed');
+        // failed to apply client state to server, so revert stream mute state to server state
+        this.muteLocalStream(
+          meeting,
+          this.state.server.localMute || this.state.server.remoteMute,
+          'clientRequestFailed'
+        );
       });
   }
 
@@ -325,18 +345,6 @@ export class MuteState {
       });
   }
 
-  /** Sets the mute state of the local stream according to what server thinks is our state
-   * @param {Object} meeting - the meeting object
-   * @param {ServerMuteReason} serverMuteReason - reason why we're applying server mute to the local stream
-   * @returns {void}
-   */
-  private applyServerMuteToLocalStream(meeting: any, serverMuteReason: ServerMuteReason) {
-    const muted = this.state.server.localMute || this.state.server.remoteMute;
-
-    // update the local stream mute state, but not this.state.client.localMute
-    this.muteLocalStream(meeting, muted, serverMuteReason);
-  }
-
   /** Applies the current value for unmute allowed to the underlying stream
    *
    * @param {Meeting} meeting
@@ -371,7 +379,7 @@ export class MuteState {
     }
     if (muted !== undefined) {
       this.state.server.remoteMute = muted;
-      this.applyServerMuteToLocalStream(meeting, 'remotelyMuted');
+      this.muteLocalStream(meeting, muted, 'remotelyMuted');
     }
   }
 
@@ -383,7 +391,7 @@ export class MuteState {
    * @param {Object} [meeting] the meeting object
    * @returns {undefined}
    */
-  public handleServerLocalUnmuteRequired(meeting?: object) {
+  public handleServerLocalUnmuteRequired(meeting?: any) {
     if (!this.state.client.enabled) {
       LoggerProxy.logger.warn(
         `Meeting:muteState#handleServerLocalUnmuteRequired --> ${this.type}: localAudioUnmuteRequired received while ${this.type} is disabled -> local unmute will not result in ${this.type} being sent`
@@ -396,9 +404,15 @@ export class MuteState {
 
     // todo: I'm seeing "you can now unmute yourself " popup  when this happens - but same thing happens on web.w.c so we can ignore for now
     this.state.server.remoteMute = false;
-    this.state.client.localMute = false;
 
-    this.applyClientStateLocally(meeting, 'localUnmuteRequired');
+    // change user mute state to false, but keep localMute true if overall mute state is still true
+    this.muteLocalStream(meeting, false, 'localUnmuteRequired');
+    if (this.type === AUDIO) {
+      this.state.client.localMute = meeting.mediaProperties.audioStream?.muted;
+    } else {
+      this.state.client.localMute = meeting.mediaProperties.videoStream?.muted;
+    }
+
     this.applyClientStateToServer(meeting);
   }
 

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) {
@@ -416,7 +428,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
           `Meeting:request#getLocusDTO --> Error getting latest locus, error ${err}`
         );
 
-        return err;
+        throw err;
       });
     }
 
@@ -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';
@@ -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-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

@@ -279,9 +279,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 +336,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/utilv2.ts

@@ -195,7 +195,7 @@ MeetingInfoUtil.getDestinationType = async (from) => {
     });
   } 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);
+  }
 }