@webex/plugin-meetings 3.0.0-beta.7 → 3.0.0-beta.71

package/src/meeting/{muteState.js → muteState.ts}

@@ -1,17 +1,15 @@
-
 import LoggerProxy from '../common/logs/logger-proxy';
 import ParameterError from '../common/errors/parameter';
 import PermissionError from '../common/errors/permission';
-import Media from '../media';
-import MeetingUtil from '../meeting/util';
+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
 */
 
-const createMuteState = (type, meeting, mediaDirection) => {
+// eslint-disable-next-line import/prefer-default-export
+export const createMuteState = (type, meeting, mediaDirection) => {
   if (type === AUDIO && !mediaDirection.sendAudio) {
     return null;
   }
@@ -19,7 +17,9 @@ const createMuteState = (type, meeting, mediaDirection) => {
     return null;
   }
 
-  LoggerProxy.logger.info(`Meeting:muteState#createMuteState --> ${type}: creating MuteState for meeting id ${meeting?.id}`);
+  LoggerProxy.logger.info(
+    `Meeting:muteState#createMuteState --> ${type}: creating MuteState for meeting id ${meeting?.id}`
+  );
 
   return new MuteState(type, meeting);
 };
@@ -30,28 +30,33 @@ const createMuteState = (type, meeting, mediaDirection) => {
    More info about Locus muting API: https://sqbu-github.cisco.com/pages/WebExSquared/locus/guides/mute.html#
 */
 class MuteState {
+  pendingPromiseReject: any;
+  pendingPromiseResolve: any;
+  state: any;
+  type: any;
+
   /**
    * Constructor
    *
    * @param {String} type - audio or video
    * @param {Object} meeting - the meeting object (used for reading current remote mute status)
    */
-  constructor(type, meeting) {
-    if ((type !== AUDIO) && (type !== VIDEO)) {
+  constructor(type: string, meeting: any) {
+    if (type !== AUDIO && type !== VIDEO) {
       throw new ParameterError('Mute state is designed for handling audio or video only');
     }
     this.type = type;
     this.state = {
       client: {
-        localMute: false
+        localMute: false,
       },
       server: {
         localMute: false,
-        // initial values available only for audio (REMOTE_MUTE_VIDEO_MISSING_IMPLEMENTATION)
-        remoteMute: type === AUDIO ? meeting.remoteMuted : false,
-        unmuteAllowed: type === AUDIO ? meeting.unmuteAllowed : 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
+      syncToServerInProgress: false,
     };
     // these 2 hold the resolve, reject methods for the promise we returned to the client in last handleClientRequest() call
     this.pendingPromiseResolve = null;
@@ -72,11 +77,15 @@ class MuteState {
    * @param {Boolean} [mute] true for muting, false for unmuting request
    * @returns {Promise}
    */
-  handleClientRequest(meeting, mute) {
-    LoggerProxy.logger.info(`Meeting:muteState#handleClientRequest --> ${this.type}: user requesting new mute state: ${mute}`);
+  public handleClientRequest(meeting?: object, mute?: boolean) {
+    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)'));
+      return Promise.reject(
+        new PermissionError('User is not allowed to unmute self (hard mute feature is being used)')
+      );
     }
 
     // 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,
@@ -103,11 +112,12 @@ class MuteState {
    * @memberof MuteState
    * @returns {void}
    */
-  applyClientStateLocally(meeting) {
-    Media.setLocalTrack(
-      !this.state.client.localMute,
-      (this.type === AUDIO) ? meeting.mediaProperties.audioTrack : meeting.mediaProperties.videoTrack
-    );
+  public applyClientStateLocally(meeting?: any) {
+    if (this.type === AUDIO) {
+      meeting.mediaProperties.audioTrack?.setMuted(this.state.client.localMute);
+    } else {
+      meeting.mediaProperties.videoTrack?.setMuted(this.state.client.localMute);
+    }
   }
 
   /**
@@ -118,21 +128,29 @@ class MuteState {
    * @memberof MuteState
    * @returns {void}
    */
-  applyClientStateToServer(meeting) {
+  private applyClientStateToServer(meeting?: object) {
     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`);
+      LoggerProxy.logger.info(
+        `Meeting:muteState#applyClientStateToServer --> ${this.type}: request to server in progress, we need to wait for it to complete`
+      );
 
       return;
     }
 
-    const localMuteRequiresSync = (this.state.client.localMute !== this.state.server.localMute);
-    const remoteMuteRequiresSync = (!this.state.client.localMute && this.state.server.remoteMute);
+    const localMuteRequiresSync = this.state.client.localMute !== this.state.server.localMute;
+    const remoteMuteRequiresSync = !this.state.client.localMute && this.state.server.remoteMute;
 
-    LoggerProxy.logger.info(`Meeting:muteState#applyClientStateToServer --> ${this.type}: localMuteRequiresSync: ${localMuteRequiresSync} (${this.state.client.localMute} ?= ${this.state.server.localMute})`);
-    LoggerProxy.logger.info(`Meeting:muteState#applyClientStateToServer --> ${this.type}: remoteMuteRequiresSync: ${remoteMuteRequiresSync}`);
+    LoggerProxy.logger.info(
+      `Meeting:muteState#applyClientStateToServer --> ${this.type}: localMuteRequiresSync: ${localMuteRequiresSync} (${this.state.client.localMute} ?= ${this.state.server.localMute})`
+    );
+    LoggerProxy.logger.info(
+      `Meeting:muteState#applyClientStateToServer --> ${this.type}: remoteMuteRequiresSync: ${remoteMuteRequiresSync}`
+    );
 
     if (!localMuteRequiresSync && !remoteMuteRequiresSync) {
-      LoggerProxy.logger.info(`Meeting:muteState#applyClientStateToServer --> ${this.type}: client state already matching server state, nothing to do`);
+      LoggerProxy.logger.info(
+        `Meeting:muteState#applyClientStateToServer --> ${this.type}: client state already matching server state, nothing to do`
+      );
 
       if (this.pendingPromiseResolve) {
         this.pendingPromiseResolve();
@@ -146,15 +164,20 @@ class MuteState {
     this.state.syncToServerInProgress = true;
 
     // first sync local mute with server
-    const localMuteSyncPromise = (localMuteRequiresSync) ? this.sendLocalMuteRequestToServer(meeting) : Promise.resolve();
+    const localMuteSyncPromise = localMuteRequiresSync
+      ? this.sendLocalMuteRequestToServer(meeting)
+      : Promise.resolve();
 
     localMuteSyncPromise
       .then(() =>
         // then follow it up with remote mute sync
-        ((remoteMuteRequiresSync) ? this.sendRemoteMuteRequestToServer(meeting) : Promise.resolve()))
+        remoteMuteRequiresSync ? this.sendRemoteMuteRequestToServer(meeting) : Promise.resolve()
+      )
       .then(() => {
         this.state.syncToServerInProgress = false;
-        LoggerProxy.logger.info(`Meeting:muteState#applyClientStateToServer --> ${this.type}: sync with server completed`);
+        LoggerProxy.logger.info(
+          `Meeting:muteState#applyClientStateToServer --> ${this.type}: sync with server completed`
+        );
 
         // need to check if a new sync is required, because this.state.client may have changed while we were doing the current sync
         this.applyClientStateToServer(meeting);
@@ -178,11 +201,15 @@ class MuteState {
    * @memberof MuteState
    * @returns {Promise}
    */
-  sendLocalMuteRequestToServer(meeting) {
-    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;
-
-    LoggerProxy.logger.info(`Meeting:muteState#sendLocalMuteRequestToServer --> ${this.type}: sending local mute (audio=${audioMuted}, video=${videoMuted}) to server`);
+  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;
+
+    LoggerProxy.logger.info(
+      `Meeting:muteState#sendLocalMuteRequestToServer --> ${this.type}: sending local mute (audio=${audioMuted}, video=${videoMuted}) to server`
+    );
 
     return MeetingUtil.remoteUpdateAudioVideo(audioMuted, videoMuted, meeting)
       .then((locus) => {
@@ -190,7 +217,7 @@ class MuteState {
           `Meeting:muteState#sendLocalMuteRequestToServer --> ${this.type}: local mute (audio=${audioMuted}, video=${videoMuted}) applied to server`
         );
 
-        this.state.server.localMute = (this.type === AUDIO) ? audioMuted : videoMuted;
+        this.state.server.localMute = this.type === AUDIO ? audioMuted : videoMuted;
 
         meeting.locusInfo.onFullLocus(locus);
 
@@ -205,7 +232,6 @@ class MuteState {
       });
   }
 
-
   /**
    * Sets the remote mute value in the server
    *
@@ -214,33 +240,29 @@ class MuteState {
    * @memberof MuteState
    * @returns {Promise}
    */
-  sendRemoteMuteRequestToServer(meeting) {
-    if (this.type === AUDIO) {
-      const remoteMute = this.state.client.localMute;
-
-      LoggerProxy.logger.info(`Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: sending remote mute:${remoteMute} to server`);
+  private sendRemoteMuteRequestToServer(meeting?: any) {
+    const remoteMute = this.state.client.localMute;
 
-      return meeting.members.muteMember(meeting.members.selfId, remoteMute)
-        .then(() => {
-          LoggerProxy.logger.info(
-            `Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: remote mute:${remoteMute} applied to server`
-          );
-
-          this.state.server.remoteMute = remoteMute;
-        })
-        .catch((remoteUpdateError) => {
-          LoggerProxy.logger.warn(
-            `Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: failed to apply remote mute ${remoteMute} to server: ${remoteUpdateError}`
-          );
+    LoggerProxy.logger.info(
+      `Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: sending remote mute:${remoteMute} to server`
+    );
 
-          return Promise.reject(remoteUpdateError);
-        });
-    }
+    return meeting.members
+      .muteMember(meeting.members.selfId, remoteMute, this.type === AUDIO)
+      .then(() => {
+        LoggerProxy.logger.info(
+          `Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: remote mute:${remoteMute} applied to server`
+        );
 
-    // for now we don't need to support remote muting of video (REMOTE_MUTE_VIDEO_MISSING_IMPLEMENTATION)
-    this.state.server.remoteMute = this.state.client.localMute;
+        this.state.server.remoteMute = remoteMute;
+      })
+      .catch((remoteUpdateError) => {
+        LoggerProxy.logger.warn(
+          `Meeting:muteState#sendRemoteMuteRequestToServer --> ${this.type}: failed to apply remote mute ${remoteMute} to server: ${remoteUpdateError}`
+        );
 
-    return Promise.resolve();
+        return Promise.reject(remoteUpdateError);
+      });
   }
 
   /**
@@ -252,10 +274,16 @@ class MuteState {
    * @param {Boolean} [unmuteAllowed] indicates if user is allowed to unmute self (false when "hard mute" feature is used)
    * @returns {undefined}
    */
-  handleServerRemoteMuteUpdate(muted, unmuteAllowed) {
-    LoggerProxy.logger.info(`Meeting:muteState#handleServerRemoteMuteUpdate --> ${this.type}: updating server remoteMute to (${muted})`);
-    this.state.server.remoteMute = muted;
-    this.state.server.unmuteAllowed = unmuteAllowed;
+  public handleServerRemoteMuteUpdate(muted?: boolean, unmuteAllowed?: boolean) {
+    LoggerProxy.logger.info(
+      `Meeting:muteState#handleServerRemoteMuteUpdate --> ${this.type}: updating server remoteMute to (${muted})`
+    );
+    if (muted !== undefined) {
+      this.state.server.remoteMute = muted;
+    }
+    if (unmuteAllowed !== undefined) {
+      this.state.server.unmuteAllowed = unmuteAllowed;
+    }
   }
 
   /**
@@ -266,14 +294,18 @@ class MuteState {
    * @param {Object} [meeting] the meeting object
    * @returns {undefined}
    */
-  handleServerLocalUnmuteRequired(meeting) {
-    LoggerProxy.logger.info(`Meeting:muteState#handleServerLocalUnmuteRequired --> ${this.type}: localAudioUnmuteRequired received -> doing local unmute`);
+  public handleServerLocalUnmuteRequired(meeting?: object) {
+    LoggerProxy.logger.info(
+      `Meeting:muteState#handleServerLocalUnmuteRequired --> ${this.type}: localAudioUnmuteRequired received -> doing local unmute`
+    );
 
     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.pendingPromiseReject(
+        new Error('Server requested local unmute - this overrides any client request in progress')
+      );
       this.pendingPromiseResolve = null;
       this.pendingPromiseReject = null;
     }
@@ -289,8 +321,43 @@ class MuteState {
    * @memberof MuteState
    * @returns {Boolean}
    */
-  isMuted() {
-    return this.state.client.localMute || this.state.server.localMute || this.state.server.remoteMute;
+  public isMuted() {
+    return (
+      this.state.client.localMute || this.state.server.localMute || this.state.server.remoteMute
+    );
+  }
+
+  /**
+   * Returns true if the user is remotely muted
+   *
+   * @public
+   * @memberof MuteState
+   * @returns {Boolean}
+   */
+  public isRemotelyMuted() {
+    return this.state.server.remoteMute;
+  }
+
+  /**
+   * Returns true if unmute is allowed
+   *
+   * @public
+   * @memberof MuteState
+   * @returns {Boolean}
+   */
+  public isUnmuteAllowed() {
+    return this.state.server.unmuteAllowed;
+  }
+
+  /**
+   * Returns true if the user is locally muted
+   *
+   * @public
+   * @memberof MuteState
+   * @returns {Boolean}
+   */
+  public isLocallyMuted() {
+    return this.state.client.localMute || this.state.server.localMute;
   }
 
   /**
@@ -300,7 +367,7 @@ class MuteState {
    * @memberof MuteState
    * @returns {Boolean}
    */
-  isSelf() {
+  public isSelf() {
     return this.state.client.localMute && !this.state.server.remoteMute;
   }
 
@@ -314,5 +381,3 @@ class MuteState {
     return this.isSelf();
   }
 }
-
-export default createMuteState;