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

package/dist/meeting/muteState.js

@@ -5,33 +5,21 @@ var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequ
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createMuteState = void 0;
+exports.createMuteState = exports.MuteState = void 0;
 var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
 var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
 var _parameter = _interopRequireDefault(require("../common/errors/parameter"));
-var _permission = _interopRequireDefault(require("../common/errors/permission"));
 var _util = _interopRequireDefault(require("./util"));
 var _constants = require("../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
-var createMuteState = function createMuteState(type, meeting, mediaDirection, sdkOwnsLocalTrack) {
-  // todo: remove mediaDirection argument (SPARK-399695)
+var createMuteState = exports.createMuteState = function createMuteState(type, meeting, enabled) {
   // todo: remove the meeting argument  (SPARK-399695)
-  if (type === _constants.AUDIO && !mediaDirection.sendAudio) {
-    return null;
-  }
-  if (type === _constants.VIDEO && !mediaDirection.sendVideo) {
-    return null;
-  }
+
   _loggerProxy.default.logger.info("Meeting:muteState#createMuteState --> ".concat(type, ": creating MuteState for meeting id ").concat(meeting === null || meeting === void 0 ? void 0 : meeting.id));
-  var muteState = new MuteState(type, meeting, sdkOwnsLocalTrack);
-  muteState.init(meeting);
+  var muteState = new MuteState(type, meeting, enabled);
   return muteState;
 };
 
@@ -39,48 +27,41 @@ var createMuteState = function createMuteState(type, meeting, mediaDirection, sd
    the last requested state by the client.
 
    More info about Locus muting API: https://sqbu-github.cisco.com/pages/WebExSquared/locus/guides/mute.html#
-*/
-exports.createMuteState = createMuteState;
-var MuteState = /*#__PURE__*/function () {
-  // todo: remove this when doing SPARK-399695
 
+   This class is exported only for unit tests. It should never be instantiated directly with new MuteState(), instead createMuteState() should be called
+*/
+var MuteState = exports.MuteState = /*#__PURE__*/function () {
   /**
    * Constructor
    *
    * @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
    */
-  function MuteState(type, meeting, sdkOwnsLocalTrack) {
+  function MuteState(type, meeting, enabled) {
     var _meeting$remoteVideoM, _meeting$unmuteVideoA;
     (0, _classCallCheck2.default)(this, MuteState);
-    (0, _defineProperty2.default)(this, "pendingPromiseReject", void 0);
-    (0, _defineProperty2.default)(this, "pendingPromiseResolve", void 0);
     (0, _defineProperty2.default)(this, "state", void 0);
     (0, _defineProperty2.default)(this, "type", void 0);
-    (0, _defineProperty2.default)(this, "sdkOwnsLocalTrack", void 0);
     (0, _defineProperty2.default)(this, "ignoreMuteStateChange", void 0);
     if (type !== _constants.AUDIO && type !== _constants.VIDEO) {
       throw new _parameter.default('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: enabled,
+        localMute: true
       },
       server: {
-        localMute: false,
+        localMute: true,
         // because remoteVideoMuted and unmuteVideoAllowed are updated seperately, they might be undefined
         remoteMute: type === _constants.AUDIO ? meeting.remoteMuted : (_meeting$remoteVideoM = meeting.remoteVideoMuted) !== null && _meeting$remoteVideoM !== void 0 ? _meeting$remoteVideoM : false,
         unmuteAllowed: type === _constants.AUDIO ? meeting.unmuteAllowed : (_meeting$unmuteVideoA = meeting.unmuteVideoAllowed) !== null && _meeting$unmuteVideoA !== void 0 ? _meeting$unmuteVideoA : 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;
   }
 
   /**
@@ -92,101 +73,78 @@ var MuteState = /*#__PURE__*/function () {
   (0, _createClass2.default)(MuteState, [{
     key: "init",
     value: function init(meeting) {
-      if (!this.sdkOwnsLocalTrack) {
-        var _meeting$mediaPropert, _meeting$mediaPropert2;
-        this.applyUnmuteAllowedToTrack(meeting);
+      var _meeting$mediaPropert, _meeting$mediaPropert2;
+      this.applyUnmuteAllowedToStream(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');
-        }
-        var initialMute = this.type === _constants.AUDIO ? (_meeting$mediaPropert = meeting.mediaProperties.audioTrack) === null || _meeting$mediaPropert === void 0 ? void 0 : _meeting$mediaPropert.muted : (_meeting$mediaPropert2 = meeting.mediaProperties.videoTrack) === null || _meeting$mediaPropert2 === void 0 ? void 0 : _meeting$mediaPropert2.muted;
-        _loggerProxy.default.logger.info("Meeting:muteState#start --> ".concat(this.type, ": local track initial mute state: ").concat(initialMute));
-        if (initialMute !== undefined) {
-          this.state.client.localMute = initialMute;
-          this.applyClientStateToServer(meeting);
-        }
+      // 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');
+      }
+      var initialMute = this.type === _constants.AUDIO ? (_meeting$mediaPropert = meeting.mediaProperties.audioStream) === null || _meeting$mediaPropert === void 0 ? void 0 : _meeting$mediaPropert.muted : (_meeting$mediaPropert2 = meeting.mediaProperties.videoStream) === null || _meeting$mediaPropert2 === void 0 ? void 0 : _meeting$mediaPropert2.muted;
+      _loggerProxy.default.logger.info("Meeting:muteState#init --> ".concat(this.type, ": local stream initial mute state: ").concat(initialMute));
+      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}
      */
   }, {
-    key: "handleLocalTrackChange",
-    value: function handleLocalTrackChange(meeting) {
+    key: "handleLocalStreamChange",
+    value: function handleLocalStreamChange(meeting) {
       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 {boolean} enable
+     * @returns {void}
+     */
+  }, {
+    key: "enable",
+    value: function enable(meeting, _enable) {
+      this.state.client.enabled = _enable;
+      this.applyClientStateToServer(meeting);
+    }
+
+    /**
+     * Mutes/unmutes local stream
+     *
+     * @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}
      */
   }, {
-    key: "muteLocalTrack",
-    value: function muteLocalTrack(meeting, mute, reason) {
+    key: "muteLocalStream",
+    value: function muteLocalStream(meeting, mute, reason) {
       this.ignoreMuteStateChange = true;
       if (this.type === _constants.AUDIO) {
         var _meeting$mediaPropert3;
-        (_meeting$mediaPropert3 = meeting.mediaProperties.audioTrack) === null || _meeting$mediaPropert3 === void 0 ? void 0 : _meeting$mediaPropert3.setServerMuted(mute, reason);
+        (_meeting$mediaPropert3 = meeting.mediaProperties.audioStream) === null || _meeting$mediaPropert3 === void 0 ? void 0 : _meeting$mediaPropert3.setServerMuted(mute, reason);
       } else {
         var _meeting$mediaPropert4;
-        (_meeting$mediaPropert4 = meeting.mediaProperties.videoTrack) === null || _meeting$mediaPropert4 === void 0 ? void 0 : _meeting$mediaPropert4.setServerMuted(mute, reason);
+        (_meeting$mediaPropert4 = meeting.mediaProperties.videoStream) === null || _meeting$mediaPropert4 === void 0 ? void 0 : _meeting$mediaPropert4.setServerMuted(mute, reason);
       }
       this.ignoreMuteStateChange = false;
     }
 
     /**
-     * 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.
-     *
-     * 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}
-     */
-  }, {
-    key: "handleClientRequest",
-    value: function handleClientRequest(meeting, mute) {
-      var _this = this;
-      // todo: this whole method will be removed in SPARK-399695
-      _loggerProxy.default.logger.info("Meeting:muteState#handleClientRequest --> ".concat(this.type, ": user requesting new mute state: ").concat(mute));
-      if (!mute && !this.state.server.unmuteAllowed) {
-        return _promise.default.reject(new _permission.default('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,
-      // because the client may have changed the audio/video tracks
-      this.state.client.localMute = mute;
-      this.applyClientStateLocally(meeting);
-      return new _promise.default(function (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 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
@@ -194,42 +152,40 @@ var MuteState = /*#__PURE__*/function () {
      * @returns {void}
      */
   }, {
-    key: "handleLocalTrackMuteStateChange",
-    value: function handleLocalTrackMuteStateChange(meeting, mute) {
+    key: "handleLocalStreamMuteStateChange",
+    value: function handleLocalStreamMuteStateChange(meeting, mute) {
       if (this.ignoreMuteStateChange) {
         return;
       }
-      _loggerProxy.default.logger.info("Meeting:muteState#handleLocalTrackMuteStateChange --> ".concat(this.type, ": local track new mute state: ").concat(mute));
-      if (this.pendingPromiseReject) {
-        _loggerProxy.default.logger.error("Meeting:muteState#handleLocalTrackMuteStateChange --> ".concat(this.type, ": Local track mute state change handler called while a client request is handled - this should never happen!, mute state: ").concat(mute));
-      }
+      _loggerProxy.default.logger.info("Meeting:muteState#handleLocalStreamMuteStateChange --> ".concat(this.type, ": local stream new mute state: ").concat(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}
      */
   }, {
     key: "applyClientStateLocally",
     value: function applyClientStateLocally(meeting, reason) {
-      if (this.sdkOwnsLocalTrack) {
-        if (this.type === _constants.AUDIO) {
-          var _meeting$mediaPropert5;
-          (_meeting$mediaPropert5 = meeting.mediaProperties.audioTrack) === null || _meeting$mediaPropert5 === void 0 ? void 0 : _meeting$mediaPropert5.setMuted(this.state.client.localMute);
-        } else {
-          var _meeting$mediaPropert6;
-          (_meeting$mediaPropert6 = meeting.mediaProperties.videoTrack) === null || _meeting$mediaPropert6 === void 0 ? void 0 : _meeting$mediaPropert6.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}
+     */
+  }, {
+    key: "getClientLocalMuteState",
+    value: function getClientLocalMuteState() {
+      return this.state.client.enabled ? this.state.client.localMute : true;
     }
 
     /**
@@ -243,22 +199,18 @@ var MuteState = /*#__PURE__*/function () {
   }, {
     key: "applyClientStateToServer",
     value: function applyClientStateToServer(meeting) {
-      var _this2 = this;
+      var _this = this;
       if (this.state.syncToServerInProgress) {
         _loggerProxy.default.logger.info("Meeting:muteState#applyClientStateToServer --> ".concat(this.type, ": request to server in progress, we need to wait for it to complete"));
         return;
       }
-      var localMuteRequiresSync = this.state.client.localMute !== this.state.server.localMute;
-      var remoteMuteRequiresSync = !this.state.client.localMute && this.state.server.remoteMute;
-      _loggerProxy.default.logger.info("Meeting:muteState#applyClientStateToServer --> ".concat(this.type, ": localMuteRequiresSync: ").concat(localMuteRequiresSync, " (").concat(this.state.client.localMute, " ?= ").concat(this.state.server.localMute, ")"));
+      var localMuteState = this.getClientLocalMuteState();
+      var localMuteRequiresSync = localMuteState !== this.state.server.localMute;
+      var remoteMuteRequiresSync = !localMuteState && this.state.server.remoteMute;
+      _loggerProxy.default.logger.info("Meeting:muteState#applyClientStateToServer --> ".concat(this.type, ": localMuteRequiresSync: ").concat(localMuteRequiresSync, " (").concat(localMuteState, " ?= ").concat(this.state.server.localMute, ")"));
       _loggerProxy.default.logger.info("Meeting:muteState#applyClientStateToServer --> ".concat(this.type, ": remoteMuteRequiresSync: ").concat(remoteMuteRequiresSync));
       if (!localMuteRequiresSync && !remoteMuteRequiresSync) {
         _loggerProxy.default.logger.info("Meeting:muteState#applyClientStateToServer --> ".concat(this.type, ": client state already matching server state, nothing to do"));
-        if (this.pendingPromiseResolve) {
-          this.pendingPromiseResolve();
-        }
-        this.pendingPromiseResolve = null;
-        this.pendingPromiseReject = null;
         return;
       }
       this.state.syncToServerInProgress = true;
@@ -268,22 +220,18 @@ var MuteState = /*#__PURE__*/function () {
       localMuteSyncPromise.then(function () {
         return (
           // then follow it up with remote mute sync
-          remoteMuteRequiresSync ? _this2.sendRemoteMuteRequestToServer(meeting) : _promise.default.resolve()
+          remoteMuteRequiresSync ? _this.sendRemoteMuteRequestToServer(meeting) : _promise.default.resolve()
         );
       }).then(function () {
-        _this2.state.syncToServerInProgress = false;
-        _loggerProxy.default.logger.info("Meeting:muteState#applyClientStateToServer --> ".concat(_this2.type, ": sync with server completed"));
+        _this.state.syncToServerInProgress = false;
+        _loggerProxy.default.logger.info("Meeting:muteState#applyClientStateToServer --> ".concat(_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
-        _this2.applyClientStateToServer(meeting);
+        _this.applyClientStateToServer(meeting);
       }).catch(function (e) {
-        _this2.state.syncToServerInProgress = false;
-        if (_this2.pendingPromiseReject) {
-          _this2.pendingPromiseReject(e);
-        }
-        _this2.pendingPromiseResolve = null;
-        _this2.pendingPromiseReject = null;
-        _this2.applyServerMuteToLocalTrack(meeting, 'clientRequestFailed');
+        _this.state.syncToServerInProgress = false;
+        _loggerProxy.default.logger.warn("Meeting:muteState#applyClientStateToServer --> ".concat(_this.type, ": error: ").concat(e));
+        _this.applyServerMuteToLocalStream(meeting, 'clientRequestFailed');
       });
     }
 
@@ -298,19 +246,19 @@ var MuteState = /*#__PURE__*/function () {
   }, {
     key: "sendLocalMuteRequestToServer",
     value: function sendLocalMuteRequestToServer(meeting) {
-      var _meeting$audio,
-        _meeting$video,
-        _this3 = this;
-      var audioMuted = this.type === _constants.AUDIO ? this.state.client.localMute : (_meeting$audio = meeting.audio) === null || _meeting$audio === void 0 ? void 0 : _meeting$audio.state.client.localMute;
-      var videoMuted = this.type === _constants.VIDEO ? this.state.client.localMute : (_meeting$video = meeting.video) === null || _meeting$video === void 0 ? void 0 : _meeting$video.state.client.localMute;
+      var _this2 = this;
+      var audioMuted = this.type === _constants.AUDIO ? this.getClientLocalMuteState() : undefined;
+      var videoMuted = this.type === _constants.VIDEO ? this.getClientLocalMuteState() : undefined;
       _loggerProxy.default.logger.info("Meeting:muteState#sendLocalMuteRequestToServer --> ".concat(this.type, ": sending local mute (audio=").concat(audioMuted, ", video=").concat(videoMuted, ") to server"));
-      return _util.default.remoteUpdateAudioVideo(audioMuted, videoMuted, meeting).then(function (locus) {
-        _loggerProxy.default.logger.info("Meeting:muteState#sendLocalMuteRequestToServer --> ".concat(_this3.type, ": local mute (audio=").concat(audioMuted, ", video=").concat(videoMuted, ") applied to server"));
-        _this3.state.server.localMute = _this3.type === _constants.AUDIO ? audioMuted : videoMuted;
-        meeting.locusInfo.onFullLocus(locus);
+      return _util.default.remoteUpdateAudioVideo(meeting, audioMuted, videoMuted).then(function (locus) {
+        _loggerProxy.default.logger.info("Meeting:muteState#sendLocalMuteRequestToServer --> ".concat(_this2.type, ": local mute (audio=").concat(audioMuted, ", video=").concat(videoMuted, ") applied to server"));
+        _this2.state.server.localMute = _this2.type === _constants.AUDIO ? audioMuted : videoMuted;
+        if (locus) {
+          meeting.locusInfo.handleLocusDelta(locus, meeting);
+        }
         return locus;
       }).catch(function (remoteUpdateError) {
-        _loggerProxy.default.logger.warn("Meeting:muteState#sendLocalMuteRequestToServer --> ".concat(_this3.type, ": failed to apply local mute (audio=").concat(audioMuted, ", video=").concat(videoMuted, ") to server: ").concat(remoteUpdateError));
+        _loggerProxy.default.logger.warn("Meeting:muteState#sendLocalMuteRequestToServer --> ".concat(_this2.type, ": failed to apply local mute (audio=").concat(audioMuted, ", video=").concat(videoMuted, ") to server: ").concat(remoteUpdateError));
         return _promise.default.reject(remoteUpdateError);
       });
     }
@@ -326,50 +274,47 @@ var MuteState = /*#__PURE__*/function () {
   }, {
     key: "sendRemoteMuteRequestToServer",
     value: function sendRemoteMuteRequestToServer(meeting) {
-      var _this4 = this;
-      var remoteMute = this.state.client.localMute;
+      var _this3 = this;
+      var remoteMute = this.getClientLocalMuteState();
       _loggerProxy.default.logger.info("Meeting:muteState#sendRemoteMuteRequestToServer --> ".concat(this.type, ": sending remote mute:").concat(remoteMute, " to server"));
       return meeting.members.muteMember(meeting.members.selfId, remoteMute, this.type === _constants.AUDIO).then(function () {
-        _loggerProxy.default.logger.info("Meeting:muteState#sendRemoteMuteRequestToServer --> ".concat(_this4.type, ": remote mute:").concat(remoteMute, " applied to server"));
-        _this4.state.server.remoteMute = remoteMute;
+        _loggerProxy.default.logger.info("Meeting:muteState#sendRemoteMuteRequestToServer --> ".concat(_this3.type, ": remote mute:").concat(remoteMute, " applied to server"));
+        _this3.state.server.remoteMute = remoteMute;
       }).catch(function (remoteUpdateError) {
-        _loggerProxy.default.logger.warn("Meeting:muteState#sendRemoteMuteRequestToServer --> ".concat(_this4.type, ": failed to apply remote mute ").concat(remoteMute, " to server: ").concat(remoteUpdateError));
+        _loggerProxy.default.logger.warn("Meeting:muteState#sendRemoteMuteRequestToServer --> ".concat(_this3.type, ": failed to apply remote mute ").concat(remoteMute, " to server: ").concat(remoteUpdateError));
         return _promise.default.reject(remoteUpdateError);
       });
     }
 
-    /** 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}
      */
   }, {
-    key: "applyServerMuteToLocalTrack",
-    value: function applyServerMuteToLocalTrack(meeting, serverMuteReason) {
-      if (!this.sdkOwnsLocalTrack) {
-        var muted = this.state.server.localMute || this.state.server.remoteMute;
+    key: "applyServerMuteToLocalStream",
+    value: function applyServerMuteToLocalStream(meeting, serverMuteReason) {
+      var 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}
      */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
   }, {
-    key: "applyUnmuteAllowedToTrack",
-    value: function applyUnmuteAllowedToTrack(meeting) {
-      if (!this.sdkOwnsLocalTrack) {
-        if (this.type === _constants.AUDIO) {
-          var _meeting$mediaPropert7;
-          (_meeting$mediaPropert7 = meeting.mediaProperties.audioTrack) === null || _meeting$mediaPropert7 === void 0 ? void 0 : _meeting$mediaPropert7.setUnmuteAllowed(this.state.server.unmuteAllowed);
-        } else {
-          var _meeting$mediaPropert8;
-          (_meeting$mediaPropert8 = meeting.mediaProperties.videoTrack) === null || _meeting$mediaPropert8 === void 0 ? void 0 : _meeting$mediaPropert8.setUnmuteAllowed(this.state.server.unmuteAllowed);
-        }
+    key: "applyUnmuteAllowedToStream",
+    value: function applyUnmuteAllowedToStream(meeting) {
+      if (this.type === _constants.AUDIO) {
+        var _meeting$mediaPropert5;
+        (_meeting$mediaPropert5 = meeting.mediaProperties.audioStream) === null || _meeting$mediaPropert5 === void 0 ? void 0 : _meeting$mediaPropert5.setUnmuteAllowed(this.state.server.unmuteAllowed);
+      } else {
+        var _meeting$mediaPropert6;
+        (_meeting$mediaPropert6 = meeting.mediaProperties.videoStream) === null || _meeting$mediaPropert6 === void 0 ? void 0 : _meeting$mediaPropert6.setUnmuteAllowed(this.state.server.unmuteAllowed);
       }
     }
 
@@ -389,11 +334,11 @@ var MuteState = /*#__PURE__*/function () {
       _loggerProxy.default.logger.info("Meeting:muteState#handleServerRemoteMuteUpdate --> ".concat(this.type, ": updating server remoteMute to (").concat(muted, ")"));
       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');
       }
     }
 
@@ -408,22 +353,22 @@ var MuteState = /*#__PURE__*/function () {
   }, {
     key: "handleServerLocalUnmuteRequired",
     value: function handleServerLocalUnmuteRequired(meeting) {
-      _loggerProxy.default.logger.info("Meeting:muteState#handleServerLocalUnmuteRequired --> ".concat(this.type, ": localAudioUnmuteRequired received -> doing local unmute"));
+      if (!this.state.client.enabled) {
+        _loggerProxy.default.logger.warn("Meeting:muteState#handleServerLocalUnmuteRequired --> ".concat(this.type, ": localAudioUnmuteRequired received while ").concat(this.type, " is disabled -> local unmute will not result in ").concat(this.type, " being sent"));
+      } else {
+        _loggerProxy.default.logger.info("Meeting:muteState#handleServerLocalUnmuteRequired --> ".concat(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
@@ -462,7 +407,7 @@ var MuteState = /*#__PURE__*/function () {
     }
 
     /**
-     * Returns true if the user is locally muted
+     * Returns true if the user is locally muted or audio/video is disabled
      *
      * @public
      * @memberof MuteState
@@ -471,34 +416,7 @@ var MuteState = /*#__PURE__*/function () {
   }, {
     key: "isLocallyMuted",
     value: function 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}
-     */
-  }, {
-    key: "isSelf",
-    value: function isSelf() {
-      return this.state.client.localMute && !this.state.server.remoteMute;
-    }
-
-    // defined for backwards compatibility with the old AudioStateMachine/VideoStateMachine classes
-  }, {
-    key: "muted",
-    get: function get() {
-      return this.isMuted();
-    }
-
-    // defined for backwards compatibility with the old AudioStateMachine/VideoStateMachine classes
-  }, {
-    key: "self",
-    get: function get() {
-      return this.isSelf();
+      return this.getClientLocalMuteState();
     }
   }]);
   return MuteState;