@webex/plugin-meetings 3.0.0-next.2 → 3.0.0-next.21

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

@@ -103,6 +103,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    * @param {String} options.locale,
    * @param {Array} options.deviceCapabilities
    * @param {boolean} options.liveAnnotationSupported
+   * @param {String} options.alias
    * @returns {Promise}
    */
   async joinMeeting(options: {
@@ -122,11 +123,13 @@ export default class MeetingRequest extends StatelessWebexPlugin {
     meetingNumber: any;
     permissionToken: any;
     preferTranscoding: any;
+    reachability: any;
     breakoutsSupported: boolean;
     locale?: string;
     deviceCapabilities?: Array<string>;
     liveAnnotationSupported: boolean;
     ipVersion?: IP_VERSION;
+    alias?: string;
   }) {
     const {
       asResourceOccupant,
@@ -143,12 +146,14 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       pin,
       moveToResource,
       roapMessage,
+      reachability,
       preferTranscoding,
       breakoutsSupported,
       locale,
       deviceCapabilities = [],
       liveAnnotationSupported,
       ipVersion,
+      alias,
     } = options;
 
     LoggerProxy.logger.info('Meeting:request#joinMeeting --> Joining a meeting', correlationId);
@@ -178,6 +183,10 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       },
     };
 
+    if (alias) {
+      body.alias = alias;
+    }
+
     if (breakoutsSupported) {
       deviceCapabilities.push(BREAKOUTS.BREAKOUTS_SUPPORTED);
     }
@@ -260,8 +269,15 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       };
     }
 
-    if (roapMessage) {
-      body.localMedias = roapMessage.localMedias;
+    if (roapMessage || reachability) {
+      body.localMedias = [
+        {
+          localSdp: JSON.stringify({
+            roapMessage,
+            reachability,
+          }),
+        },
+      ];
     }
 
     /// @ts-ignore

package/src/meeting/util.ts

@@ -149,6 +149,7 @@ const MeetingUtil = {
         locusUrl: meeting.locusUrl,
         locusClusterUrl: meeting.meetingInfo?.locusClusterUrl,
         correlationId: meeting.correlationId,
+        reachability: options.reachability,
         roapMessage: options.roapMessage,
         permissionToken: meeting.permissionToken,
         resourceId: options.resourceId || null,

package/src/multistream/mediaRequestManager.ts

@@ -8,10 +8,10 @@ import {
   H264Codec,
   getRecommendedMaxBitrateForFrameSize,
   RecommendedOpusBitrates,
+  NamedMediaGroup,
 } from '@webex/internal-media-core';
 import {cloneDeepWith, debounce, isEmpty} from 'lodash';
 
-import {NamedMediaGroup} from '@webex/json-multistream';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import {ReceiveSlot, ReceiveSlotEvents} from './receiveSlot';

package/src/multistream/remoteMediaGroup.ts

@@ -2,7 +2,7 @@
 /* eslint-disable require-jsdoc */
 /* eslint-disable import/prefer-default-export */
 import {forEach} from 'lodash';
-import {NamedMediaGroup} from '@webex/json-multistream';
+import {NamedMediaGroup} from '@webex/internal-media-core';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import {getMaxFs, RemoteMedia, RemoteVideoResolution} from './remoteMedia';

package/src/multistream/remoteMediaManager.ts

@@ -1,8 +1,7 @@
 /* eslint-disable valid-jsdoc */
 import {cloneDeep, forEach, remove} from 'lodash';
 import {EventMap} from 'typed-emitter';
-import {MediaType} from '@webex/internal-media-core';
-import {NamedMediaGroup} from '@webex/json-multistream';
+import {MediaType, NamedMediaGroup} from '@webex/internal-media-core';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 import EventsScope from '../common/events/events-scope';

package/src/multistream/sendSlotManager.ts

@@ -3,10 +3,9 @@ import {
   MediaType,
   LocalStream,
   MultistreamRoapMediaConnection,
+  NamedMediaGroup,
 } from '@webex/internal-media-core';
 
-import {NamedMediaGroup} from '@webex/json-multistream';
-
 export default class SendSlotManager {
   private readonly slots: Map<MediaType, SendSlot> = new Map();
   private readonly LoggerProxy: any;

package/src/reachability/request.ts

@@ -34,17 +34,21 @@ class ReachabilityRequest {
    * @returns {Promise}
    */
   getClusters = (ipVersion?: IP_VERSION): Promise<{clusters: ClusterList; joinCookie: any}> =>
-    this.webex
-      .request({
-        method: HTTP_VERBS.GET,
-        shouldRefreshAccessToken: false,
-        api: API.CALLIOPEDISCOVERY,
-        resource: RESOURCE.CLUSTERS,
-        qs: {
-          JCSupport: 1,
-          ipver: ipVersion,
-        },
-      })
+    this.webex.internal.newMetrics.callDiagnosticLatencies
+      .measureLatency(
+        () =>
+          this.webex.request({
+            method: HTTP_VERBS.GET,
+            shouldRefreshAccessToken: false,
+            api: API.CALLIOPEDISCOVERY,
+            resource: RESOURCE.CLUSTERS,
+            qs: {
+              JCSupport: 1,
+              ipver: ipVersion,
+            },
+          }),
+        'internal.get.cluster.time'
+      )
       .then((res) => {
         const {clusters, joinCookie} = res.body;
 

package/src/reconnection-manager/index.ts

@@ -568,7 +568,7 @@ export default class ReconnectionManager {
 
     const iceServers = [];
 
-    if (turnServerResult.turnServerInfo) {
+    if (turnServerResult.turnServerInfo?.url) {
       iceServers.push({
         urls: turnServerResult.turnServerInfo.url,
         username: turnServerResult.turnServerInfo.username || '',

package/src/roap/index.ts

@@ -5,12 +5,18 @@ import {ROAP} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import RoapRequest from './request';
-import TurnDiscovery from './turnDiscovery';
+import TurnDiscovery, {TurnDiscoveryResult} from './turnDiscovery';
 import Meeting from '../meeting';
 import MeetingUtil from '../meeting/util';
 import Metrics from '../metrics';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 
+export {
+  type TurnDiscoveryResult,
+  type TurnServerInfo,
+  type TurnDiscoverySkipReason,
+} from './turnDiscovery';
+
 /**
  * Roap options
  * @typedef {Object} RoapOptions
@@ -39,7 +45,7 @@ export default class Roap extends StatelessWebexPlugin {
   options: any;
   roapHandler: any;
   roapRequest: any;
-  turnDiscovery: any;
+  turnDiscovery: TurnDiscovery;
 
   /**
    *
@@ -260,7 +266,23 @@ export default class Roap extends StatelessWebexPlugin {
    * @param {Boolean} [isForced]
    * @returns {Promise}
    */
-  doTurnDiscovery(meeting: Meeting, isReconnecting: boolean, isForced?: boolean) {
+  doTurnDiscovery(
+    meeting: Meeting,
+    isReconnecting: boolean,
+    isForced?: boolean
+  ): Promise<TurnDiscoveryResult> {
     return this.turnDiscovery.doTurnDiscovery(meeting, isReconnecting, isForced);
   }
+
+  generateTurnDiscoveryRequestMessage(meeting: Meeting, isForced: boolean) {
+    return this.turnDiscovery.generateTurnDiscoveryRequestMessage(meeting, isForced);
+  }
+
+  handleTurnDiscoveryHttpResponse(meeting: Meeting, httpResponse: object) {
+    return this.turnDiscovery.handleTurnDiscoveryHttpResponse(meeting, httpResponse);
+  }
+
+  abortTurnDiscovery() {
+    return this.turnDiscovery.abort();
+  }
 }

package/src/roap/request.ts

@@ -123,7 +123,7 @@ export default class RoapRequest extends StatelessWebexPlugin {
         );
         const {locus} = res.body;
 
-        locus.roapSeq = roapMessage.seq;
+        locus.roapSeq = options.roapMessage.seq;
 
         return {
           locus,
@@ -139,9 +139,9 @@ export default class RoapRequest extends StatelessWebexPlugin {
             rawError: err,
           },
         });
-        LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:${JSON.stringify(err, null, 2)}`);
+        LoggerProxy.logger.error(`Roap:request#sendRoap --> Error:`, err);
         LoggerProxy.logger.error(
-          `Roap:request#sendRoapRequest --> errorBody:${JSON.stringify(
+          `Roap:request#sendRoapRequest --> roapMessage that caused error:${JSON.stringify(
             roapMessage,
             null,
             2