@webex/plugin-meetings 3.0.0-bnr.4 → 3.0.0-next.1

package/src/meeting/muteState.ts

@@ -1,31 +1,18 @@
 import {ServerMuteReason} from '@webex/media-helpers';
 import LoggerProxy from '../common/logs/logger-proxy';
 import ParameterError from '../common/errors/parameter';
-import PermissionError from '../common/errors/permission';
 import MeetingUtil from './util';
 import {AUDIO, VIDEO} from '../constants';
-/* Certain aspects of server interaction for video muting are not implemented as we currently don't support remote muting of video.
-   If we ever need to support it, search for REMOTE_MUTE_VIDEO_MISSING_IMPLEMENTATION string to find the places that need updating
-*/
 
 // eslint-disable-next-line import/prefer-default-export
-export const createMuteState = (type, meeting, mediaDirection, sdkOwnsLocalTrack: boolean) => {
-  // todo: remove mediaDirection argument (SPARK-399695)
+export const createMuteState = (type, meeting, enabled: boolean) => {
   // todo: remove the meeting argument  (SPARK-399695)
-  if (type === AUDIO && !mediaDirection.sendAudio) {
-    return null;
-  }
-  if (type === VIDEO && !mediaDirection.sendVideo) {
-    return null;
-  }
 
   LoggerProxy.logger.info(
     `Meeting:muteState#createMuteState --> ${type}: creating MuteState for meeting id ${meeting?.id}`
   );
 
-  const muteState = new MuteState(type, meeting, sdkOwnsLocalTrack);
-
-  muteState.init(meeting);
+  const muteState = new MuteState(type, meeting, enabled);
 
   return muteState;
 };
@@ -34,13 +21,20 @@ export const createMuteState = (type, meeting, mediaDirection, sdkOwnsLocalTrack
    the last requested state by the client.
 
    More info about Locus muting API: https://sqbu-github.cisco.com/pages/WebExSquared/locus/guides/mute.html#
+
+   This class is exported only for unit tests. It should never be instantiated directly with new MuteState(), instead createMuteState() should be called
 */
-class MuteState {
-  pendingPromiseReject: any;
-  pendingPromiseResolve: any;
-  state: any;
+export class MuteState {
+  state: {
+    client: {
+      enabled: boolean; // indicates if audio/video is enabled at all or not
+      localMute: boolean;
+    };
+    server: {localMute: boolean; remoteMute: boolean; unmuteAllowed: boolean};
+    syncToServerInProgress: boolean;
+  };
+
   type: any;
-  sdkOwnsLocalTrack: boolean; // todo: remove this when doing SPARK-399695
   ignoreMuteStateChange: boolean;
 
   /**
@@ -48,30 +42,27 @@ class MuteState {
    *
    * @param {String} type - audio or video
    * @param {Object} meeting - the meeting object (used for reading current remote mute status)
-   * @param {boolean} sdkOwnsLocalTrack - if false, then client app owns the local track (for now that's the case only for multistream meetings)
+   * @param {boolean} enabled - whether the client audio/video is enabled at all
    */
-  constructor(type: string, meeting: any, sdkOwnsLocalTrack: boolean) {
+  constructor(type: string, meeting: any, enabled: boolean) {
     if (type !== AUDIO && type !== VIDEO) {
       throw new ParameterError('Mute state is designed for handling audio or video only');
     }
     this.type = type;
-    this.sdkOwnsLocalTrack = sdkOwnsLocalTrack;
     this.ignoreMuteStateChange = false;
     this.state = {
       client: {
-        localMute: false,
+        enabled,
+        localMute: true,
       },
       server: {
-        localMute: false,
+        localMute: true,
         // because remoteVideoMuted and unmuteVideoAllowed are updated seperately, they might be undefined
         remoteMute: type === AUDIO ? meeting.remoteMuted : meeting.remoteVideoMuted ?? false,
         unmuteAllowed: type === AUDIO ? meeting.unmuteAllowed : meeting.unmuteVideoAllowed ?? true,
       },
       syncToServerInProgress: false,
     };
-    // these 2 hold the resolve, reject methods for the promise we returned to the client in last handleClientRequest() call
-    this.pendingPromiseResolve = null;
-    this.pendingPromiseReject = null;
   }
 
   /**
@@ -81,151 +72,117 @@ class MuteState {
    * @returns {void}
    */
   public init(meeting: any) {
-    if (!this.sdkOwnsLocalTrack) {
-      this.applyUnmuteAllowedToTrack(meeting);
-
-      // if we are remotely muted, we need to apply that to the local track now (mute on-entry)
-      if (this.state.server.remoteMute) {
-        this.muteLocalTrack(meeting, this.state.server.remoteMute, 'remotelyMuted');
-      }
+    this.applyUnmuteAllowedToStream(meeting);
 
-      const initialMute =
-        this.type === AUDIO
-          ? meeting.mediaProperties.audioTrack?.muted
-          : meeting.mediaProperties.videoTrack?.muted;
+    // if we are remotely muted, we need to apply that to the local stream now (mute on-entry)
+    if (this.state.server.remoteMute) {
+      this.muteLocalStream(meeting, this.state.server.remoteMute, 'remotelyMuted');
+    }
 
-      LoggerProxy.logger.info(
-        `Meeting:muteState#start --> ${this.type}: local track initial mute state: ${initialMute}`
-      );
+    const initialMute =
+      this.type === AUDIO
+        ? meeting.mediaProperties.audioStream?.muted
+        : meeting.mediaProperties.videoStream?.muted;
 
-      if (initialMute !== undefined) {
-        this.state.client.localMute = initialMute;
+    LoggerProxy.logger.info(
+      `Meeting:muteState#init --> ${this.type}: local stream initial mute state: ${initialMute}`
+    );
 
-        this.applyClientStateToServer(meeting);
-      }
+    if (initialMute !== undefined) {
+      this.state.client.localMute = initialMute;
+    } else {
+      // there is no stream, so it's like we are locally muted
+      // (this is important especially for transcoded meetings, in which the SDP m-line direction always stays "sendrecv")
+      this.state.client.localMute = true;
     }
+    this.applyClientStateToServer(meeting);
   }
 
   /**
-   * This method needs to be called whenever the local audio/video track has changed.
-   * It reapplies the remote mute state onto the new track and also reads the current
-   * local mute state from the track and updates the internal state machine and sends
+   * This method needs to be called whenever the local audio/video stream has changed.
+   * It reapplies the remote mute state onto the new stream and also reads the current
+   * local mute state from the stream and updates the internal state machine and sends
    * any required requests to the server.
    *
    * @param {Object} meeting - the meeting object
    * @returns {void}
    */
-  public handleLocalTrackChange(meeting: any) {
+  public handleLocalStreamChange(meeting: any) {
     return this.init(meeting);
   }
 
   /**
-   * Mutes/unmutes local track
+   * Enables/disables audio/video
    *
    * @param {Object} meeting - the meeting object
-   * @param {Boolean} mute - true to mute the track, false to unmute it
-   * @param {ServerMuteReason} reason - reason for muting/unmuting
+   * @param {boolean} enable
    * @returns {void}
    */
-  private muteLocalTrack(meeting: any, mute: boolean, reason: ServerMuteReason) {
-    this.ignoreMuteStateChange = true;
-    if (this.type === AUDIO) {
-      meeting.mediaProperties.audioTrack?.setServerMuted(mute, reason);
-    } else {
-      meeting.mediaProperties.videoTrack?.setServerMuted(mute, reason);
-    }
-    this.ignoreMuteStateChange = false;
+  public enable(meeting: any, enable: boolean) {
+    this.state.client.enabled = enable;
+
+    this.applyClientStateToServer(meeting);
   }
 
   /**
-   * Handles mute/unmute request from the client/user. Returns a promise that's resolved once the server update is completed or
-   * at the point that this request becomese superseded by another client request.
+   * Mutes/unmutes local stream
    *
-   * The client doesn't have to wait for the returned promise to resolve before calling handleClientRequest() again. If
-   * handleClientRequest() is called again before the previous one resolved, the MuteState class will make sure that eventually
-   * the server state will match the last requested state from the client.
-   *
-   * @public
-   * @memberof MuteState
-   * @param {Object} [meeting] the meeting object
-   * @param {Boolean} [mute] true for muting, false for unmuting request
-   * @returns {Promise}
+   * @param {Object} meeting - the meeting object
+   * @param {Boolean} mute - true to mute the stream, false to unmute it
+   * @param {ServerMuteReason} reason - reason for muting/unmuting
+   * @returns {void}
    */
-  public handleClientRequest(meeting: object, mute?: boolean) {
-    // todo: this whole method will be removed in SPARK-399695
-    LoggerProxy.logger.info(
-      `Meeting:muteState#handleClientRequest --> ${this.type}: user requesting new mute state: ${mute}`
-    );
-
-    if (!mute && !this.state.server.unmuteAllowed) {
-      return Promise.reject(
-        new PermissionError('User is not allowed to unmute self (hard mute feature is being used)')
-      );
+  private muteLocalStream(meeting: any, mute: boolean, reason: ServerMuteReason) {
+    this.ignoreMuteStateChange = true;
+    if (this.type === AUDIO) {
+      meeting.mediaProperties.audioStream?.setServerMuted(mute, reason);
+    } else {
+      meeting.mediaProperties.videoStream?.setServerMuted(mute, reason);
     }
-
-    // we don't check if we're already in the same state, because even if we were, we would still have to apply the mute state locally,
-    // because the client may have changed the audio/video tracks
-    this.state.client.localMute = mute;
-
-    this.applyClientStateLocally(meeting);
-
-    return new Promise((resolve, reject) => {
-      if (this.pendingPromiseResolve) {
-        // resolve the last promise we returned to the client as the client has issued a new request that has superseded the previous one
-        this.pendingPromiseResolve();
-      }
-      this.pendingPromiseResolve = resolve;
-      this.pendingPromiseReject = reject;
-      this.applyClientStateToServer(meeting);
-    });
+    this.ignoreMuteStateChange = false;
   }
 
   /**
-   * This method should be called when the local track mute state is changed
+   * This method should be called when the local stream mute state is changed
    * @public
    * @memberof MuteState
    * @param {Object} [meeting] the meeting object
    * @param {Boolean} [mute] true for muting, false for unmuting request
    * @returns {void}
    */
-  public handleLocalTrackMuteStateChange(meeting?: object, mute?: boolean) {
+  public handleLocalStreamMuteStateChange(meeting?: object, mute?: boolean) {
     if (this.ignoreMuteStateChange) {
       return;
     }
     LoggerProxy.logger.info(
-      `Meeting:muteState#handleLocalTrackMuteStateChange --> ${this.type}: local track new mute state: ${mute}`
+      `Meeting:muteState#handleLocalStreamMuteStateChange --> ${this.type}: local stream new mute state: ${mute}`
     );
 
-    if (this.pendingPromiseReject) {
-      LoggerProxy.logger.error(
-        `Meeting:muteState#handleLocalTrackMuteStateChange --> ${this.type}: Local track mute state change handler called while a client request is handled - this should never happen!, mute state: ${mute}`
-      );
-    }
-
     this.state.client.localMute = mute;
 
     this.applyClientStateToServer(meeting);
   }
 
   /**
-   * Applies the current mute state to the local track (by enabling or disabling it accordingly)
+   * Applies the current mute state to the local stream (by enabling or disabling it accordingly)
    *
    * @public
    * @param {Object} [meeting] the meeting object
-   * @param {ServerMuteReason} reason - reason why we're applying our client state to the local track
+   * @param {ServerMuteReason} reason - reason why we're applying our client state to the local stream
    * @memberof MuteState
    * @returns {void}
    */
   public applyClientStateLocally(meeting?: any, reason?: ServerMuteReason) {
-    if (this.sdkOwnsLocalTrack) {
-      if (this.type === AUDIO) {
-        meeting.mediaProperties.audioTrack?.setMuted(this.state.client.localMute);
-      } else {
-        meeting.mediaProperties.videoTrack?.setMuted(this.state.client.localMute);
-      }
-    } else {
-      this.muteLocalTrack(meeting, this.state.client.localMute, reason);
-    }
+    this.muteLocalStream(meeting, this.state.client.localMute, reason);
+  }
+
+  /** Returns true if client is locally muted - it takes into account not just the client local mute state,
+   *  but also whether audio/video is enabled at all
+   *
+   * @returns {boolean}
+   */
+  private getClientLocalMuteState() {
+    return this.state.client.enabled ? this.state.client.localMute : true;
   }
 
   /**
@@ -236,7 +193,7 @@ class MuteState {
    * @memberof MuteState
    * @returns {void}
    */
-  private applyClientStateToServer(meeting?: object) {
+  private applyClientStateToServer(meeting?: any) {
     if (this.state.syncToServerInProgress) {
       LoggerProxy.logger.info(
         `Meeting:muteState#applyClientStateToServer --> ${this.type}: request to server in progress, we need to wait for it to complete`
@@ -245,11 +202,12 @@ class MuteState {
       return;
     }
 
-    const localMuteRequiresSync = this.state.client.localMute !== this.state.server.localMute;
-    const remoteMuteRequiresSync = !this.state.client.localMute && this.state.server.remoteMute;
+    const localMuteState = this.getClientLocalMuteState();
+    const localMuteRequiresSync = localMuteState !== this.state.server.localMute;
+    const remoteMuteRequiresSync = !localMuteState && this.state.server.remoteMute;
 
     LoggerProxy.logger.info(
-      `Meeting:muteState#applyClientStateToServer --> ${this.type}: localMuteRequiresSync: ${localMuteRequiresSync} (${this.state.client.localMute} ?= ${this.state.server.localMute})`
+      `Meeting:muteState#applyClientStateToServer --> ${this.type}: localMuteRequiresSync: ${localMuteRequiresSync} (${localMuteState} ?= ${this.state.server.localMute})`
     );
     LoggerProxy.logger.info(
       `Meeting:muteState#applyClientStateToServer --> ${this.type}: remoteMuteRequiresSync: ${remoteMuteRequiresSync}`
@@ -260,12 +218,6 @@ class MuteState {
         `Meeting:muteState#applyClientStateToServer --> ${this.type}: client state already matching server state, nothing to do`
       );
 
-      if (this.pendingPromiseResolve) {
-        this.pendingPromiseResolve();
-      }
-      this.pendingPromiseResolve = null;
-      this.pendingPromiseReject = null;
-
       return;
     }
 
@@ -293,13 +245,11 @@ class MuteState {
       .catch((e) => {
         this.state.syncToServerInProgress = false;
 
-        if (this.pendingPromiseReject) {
-          this.pendingPromiseReject(e);
-        }
-        this.pendingPromiseResolve = null;
-        this.pendingPromiseReject = null;
+        LoggerProxy.logger.warn(
+          `Meeting:muteState#applyClientStateToServer --> ${this.type}: error: ${e}`
+        );
 
-        this.applyServerMuteToLocalTrack(meeting, 'clientRequestFailed');
+        this.applyServerMuteToLocalStream(meeting, 'clientRequestFailed');
       });
   }
 
@@ -312,16 +262,14 @@ class MuteState {
    * @returns {Promise}
    */
   private sendLocalMuteRequestToServer(meeting?: any) {
-    const audioMuted =
-      this.type === AUDIO ? this.state.client.localMute : meeting.audio?.state.client.localMute;
-    const videoMuted =
-      this.type === VIDEO ? this.state.client.localMute : meeting.video?.state.client.localMute;
+    const audioMuted = this.type === AUDIO ? this.getClientLocalMuteState() : undefined;
+    const videoMuted = this.type === VIDEO ? this.getClientLocalMuteState() : undefined;
 
     LoggerProxy.logger.info(
       `Meeting:muteState#sendLocalMuteRequestToServer --> ${this.type}: sending local mute (audio=${audioMuted}, video=${videoMuted}) to server`
     );
 
-    return MeetingUtil.remoteUpdateAudioVideo(audioMuted, videoMuted, meeting)
+    return MeetingUtil.remoteUpdateAudioVideo(meeting, audioMuted, videoMuted)
       .then((locus) => {
         LoggerProxy.logger.info(
           `Meeting:muteState#sendLocalMuteRequestToServer --> ${this.type}: local mute (audio=${audioMuted}, video=${videoMuted}) applied to server`
@@ -329,7 +277,9 @@ class MuteState {
 
         this.state.server.localMute = this.type === AUDIO ? audioMuted : videoMuted;
 
-        meeting.locusInfo.onFullLocus(locus);
+        if (locus) {
+          meeting.locusInfo.handleLocusDelta(locus, meeting);
+        }
 
         return locus;
       })
@@ -351,7 +301,7 @@ class MuteState {
    * @returns {Promise}
    */
   private sendRemoteMuteRequestToServer(meeting?: any) {
-    const remoteMute = this.state.client.localMute;
+    const remoteMute = this.getClientLocalMuteState();
 
     LoggerProxy.logger.info(
       `Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: sending remote mute:${remoteMute} to server`
@@ -375,32 +325,29 @@ class MuteState {
       });
   }
 
-  /** Sets the mute state of the local track according to what server thinks is our state
+  /** 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 track
+   * @param {ServerMuteReason} serverMuteReason - reason why we're applying server mute to the local stream
    * @returns {void}
    */
-  private applyServerMuteToLocalTrack(meeting: any, serverMuteReason: ServerMuteReason) {
-    if (!this.sdkOwnsLocalTrack) {
-      const muted = this.state.server.localMute || this.state.server.remoteMute;
+  private applyServerMuteToLocalStream(meeting: any, serverMuteReason: ServerMuteReason) {
+    const muted = this.state.server.localMute || this.state.server.remoteMute;
 
-      // update the local track mute state, but not this.state.client.localMute
-      this.muteLocalTrack(meeting, muted, serverMuteReason);
-    }
+    // 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 track
+  /** Applies the current value for unmute allowed to the underlying stream
    *
    * @param {Meeting} meeting
    * @returns {void}
    */
-  private applyUnmuteAllowedToTrack(meeting: any) {
-    if (!this.sdkOwnsLocalTrack) {
-      if (this.type === AUDIO) {
-        meeting.mediaProperties.audioTrack?.setUnmuteAllowed(this.state.server.unmuteAllowed);
-      } else {
-        meeting.mediaProperties.videoTrack?.setUnmuteAllowed(this.state.server.unmuteAllowed);
-      }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private applyUnmuteAllowedToStream(meeting: any) {
+    if (this.type === AUDIO) {
+      meeting.mediaProperties.audioStream?.setUnmuteAllowed(this.state.server.unmuteAllowed);
+    } else {
+      meeting.mediaProperties.videoStream?.setUnmuteAllowed(this.state.server.unmuteAllowed);
     }
   }
 
@@ -420,11 +367,11 @@ class MuteState {
     );
     if (unmuteAllowed !== undefined) {
       this.state.server.unmuteAllowed = unmuteAllowed;
-      this.applyUnmuteAllowedToTrack(meeting);
+      this.applyUnmuteAllowedToStream(meeting);
     }
     if (muted !== undefined) {
       this.state.server.remoteMute = muted;
-      this.applyServerMuteToLocalTrack(meeting, 'remotelyMuted');
+      this.applyServerMuteToLocalStream(meeting, 'remotelyMuted');
     }
   }
 
@@ -437,28 +384,27 @@ class MuteState {
    * @returns {undefined}
    */
   public handleServerLocalUnmuteRequired(meeting?: object) {
-    LoggerProxy.logger.info(
-      `Meeting:muteState#handleServerLocalUnmuteRequired --> ${this.type}: localAudioUnmuteRequired received -> doing local unmute`
-    );
+    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`
+      );
+    } else {
+      LoggerProxy.logger.info(
+        `Meeting:muteState#handleServerLocalUnmuteRequired --> ${this.type}: localAudioUnmuteRequired received -> doing local unmute`
+      );
+    }
 
     // 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;
 
-    if (this.pendingPromiseReject) {
-      this.pendingPromiseReject(
-        new Error('Server requested local unmute - this overrides any client request in progress')
-      );
-      this.pendingPromiseResolve = null;
-      this.pendingPromiseReject = null;
-    }
-
     this.applyClientStateLocally(meeting, 'localUnmuteRequired');
     this.applyClientStateToServer(meeting);
   }
 
   /**
-   * Returns true if the user is locally or remotely muted
+   * Returns true if the user is locally or remotely muted.
+   * It only checks the mute status, ignoring the fact whether audio/video is enabled.
    *
    * @public
    * @memberof MuteState
@@ -493,34 +439,13 @@ class MuteState {
   }
 
   /**
-   * Returns true if the user is locally muted
+   * Returns true if the user is locally muted or audio/video is disabled
    *
    * @public
    * @memberof MuteState
    * @returns {Boolean}
    */
   public isLocallyMuted() {
-    return this.state.client.localMute || this.state.server.localMute;
-  }
-
-  /**
-   * Returns true if the user is muted as a result of the client request (and not remotely muted)
-   *
-   * @public
-   * @memberof MuteState
-   * @returns {Boolean}
-   */
-  public isSelf() {
-    return this.state.client.localMute && !this.state.server.remoteMute;
-  }
-
-  // defined for backwards compatibility with the old AudioStateMachine/VideoStateMachine classes
-  get muted() {
-    return this.isMuted();
-  }
-
-  // defined for backwards compatibility with the old AudioStateMachine/VideoStateMachine classes
-  get self() {
-    return this.isSelf();
+    return this.getClientLocalMuteState();
   }
 }