Returns Promise from mute/unmute and ignores requests while mute/unmuting is in progress. Moves mute/unmute methods to JitsiLocalTrack as said in API docs.

JitsiConference.js

 
     conference.room.addListener(XMPPEvents.AUDIO_MUTED_BY_FOCUS,
         function (value) {
-            conference.rtc.setAudioMute(value);
-            conference.isMutedByFocus = true;
+            // set isMutedByFocus when setAudioMute Promise ends
+            conference.rtc.setAudioMute(value).then(
+                function() {
+                    conference.isMutedByFocus = true;
+                },
+                function() {
+                    logger.warn(
+                        "Error while audio muting due to focus request");
+                });
         }
     );
 

JitsiTrackErrors.js

     CHROME_EXTENSION_USER_CANCELED:
         "gum.chrome_extension_user_canceled",
     GENERAL: "gum.general",
-    TRACK_IS_DISPOSED: "track.track_is_disposed"
+    TRACK_IS_DISPOSED: "track.track_is_disposed",
+    TRACK_MUTE_UNMUTE_IN_PROGRESS: "track.mute_unmute_inprogress"
 };

doc/API.md

 1. getType() - returns string with the type of the track( "video" for the video tracks and "audio" for the audio tracks)
 
 
-2. mute() - mutes the track.
+2. mute() - mutes the track. Returns Promise.
 
    Note: This method is implemented only for the local tracks.
 
-
-3. unmute() - unmutes the track.
+3. unmute() - unmutes the track. Returns Promise.
 
    Note: This method is implemented only for the local tracks.
 

modules/RTC/JitsiLocalTrack.js

 var JitsiTrack = require("./JitsiTrack");
 var RTCBrowserType = require("./RTCBrowserType");
 var JitsiTrackEvents = require('../../JitsiTrackEvents');
+var JitsiTrackErrors = require("../../JitsiTrackErrors");
 var RTCUtils = require("./RTCUtils");
 
 /**
             this.dontFireRemoveEvent = false;
         }.bind(this));
     this.initialMSID = this.getMSID();
+    this.inMuteOrUnmuteProcess = false;
 }
 
 JitsiLocalTrack.prototype = Object.create(JitsiTrack.prototype);
 JitsiLocalTrack.prototype.constructor = JitsiLocalTrack;
 
+/**
+ * Mutes the track. Will reject the Promise if there is mute/unmute operation
+ * in progress.
+ * @returns {Promise}
+ */
+JitsiLocalTrack.prototype.mute = function () {
+    return new Promise(function (resolve, reject) {
+
+        if(this.inMuteOrUnmuteProcess) {
+            reject(new Error(JitsiTrackErrors.TRACK_MUTE_UNMUTE_IN_PROGRESS));
+            return;
+        }
+        this.inMuteOrUnmuteProcess = true;
+
+        this._setMute(true,
+            function(){
+                this.inMuteOrUnmuteProcess = false;
+                resolve();
+            }.bind(this),
+            function(status){
+                this.inMuteOrUnmuteProcess = false;
+                reject(status);
+            }.bind(this));
+    }.bind(this));
+}
+
+/**
+ * Unmutes the stream. Will reject the Promise if there is mute/unmute operation
+ * in progress.
+ * @returns {Promise}
+ */
+JitsiLocalTrack.prototype.unmute = function () {
+    return new Promise(function (resolve, reject) {
+
+        if(this.inMuteOrUnmuteProcess) {
+            reject(new Error(JitsiTrackErrors.TRACK_MUTE_UNMUTE_IN_PROGRESS));
+            return;
+        }
+        this.inMuteOrUnmuteProcess = true;
+
+        this._setMute(false,
+            function(){
+                this.inMuteOrUnmuteProcess = false;
+                resolve();
+            }.bind(this),
+            function(status){
+                this.inMuteOrUnmuteProcess = false;
+                reject(status);
+            }.bind(this));
+    }.bind(this));
+}
+
 /**
  * Mutes / unmutes the track.
  * @param mute {boolean} if true the track will be muted. Otherwise the track will be unmuted.
  */
-JitsiLocalTrack.prototype._setMute = function (mute) {
+JitsiLocalTrack.prototype._setMute = function (mute, resolve, reject) {
     if (this.isMuted() === mute) {
+        resolve();
         return;
     }
     if(!this.rtc) {
         this.startMuted = mute;
+        resolve();
         return;
     }
     var isAudio = this.type === JitsiTrack.AUDIO;
     this.dontFireRemoveEvent = false;
 
+    var setStreamToNull = false;
+    // the callback that will notify that operation had finished
+    var callbackFunction = function() {
+
+        if(setStreamToNull)
+            this.stream = null;
+        this.eventEmitter.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED);
+
+        resolve();
+    }.bind(this);
+
     if ((window.location.protocol != "https:") ||
         (isAudio) || this.videoType === "desktop" ||
         // FIXME FF does not support 'removeStream' method used to mute
             tracks[idx].enabled = !mute;
         }
         if(isAudio)
-            this.rtc.room.setAudioMute(mute);
+            this.rtc.room.setAudioMute(mute, callbackFunction);
         else
-            this.rtc.room.setVideoMute(mute);
-        this.eventEmitter.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED);
+            this.rtc.room.setVideoMute(mute, callbackFunction);
     } else {
         if (mute) {
             this.dontFireRemoveEvent = true;
             this.rtc.room.removeStream(this.stream, function () {},
                 {mtype: this.type, type: "mute", ssrc: this.ssrc});
             RTCUtils.stopMediaStream(this.stream);
+            setStreamToNull = true;
             if(isAudio)
-                this.rtc.room.setAudioMute(mute);
+                this.rtc.room.setAudioMute(mute, callbackFunction);
             else
-                this.rtc.room.setVideoMute(mute);
-            this.stream = null;
-            this.eventEmitter.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED);
+                this.rtc.room.setVideoMute(mute, callbackFunction);
             //FIXME: Maybe here we should set the SRC for the containers to something
         } else {
             var self = this;
                         }
                     }
 
-                    if(!stream)
+                    if(!stream) {
+                        reject(new Error('track.no_stream_found'));
                         return;
+                    }
 
                     for(var i = 0; i < self.containers.length; i++)
                     {
                     self.rtc.room.addStream(self.stream,
                         function () {
                             if(isAudio)
-                                self.rtc.room.setAudioMute(mute);
+                                self.rtc.room.setAudioMute(
+                                    mute, callbackFunction);
                             else
-                                self.rtc.room.setVideoMute(mute);
-                            self.eventEmitter.emit(
-                                JitsiTrackEvents.TRACK_MUTE_CHANGED);
+                                self.rtc.room.setVideoMute(
+                                    mute, callbackFunction);
                         }, {
                             mtype: self.type,
                             type: "unmute",

modules/RTC/JitsiTrack.js

     }
 };
 
-/**
- * Mutes the track.
- */
-JitsiTrack.prototype.mute = function () {
-    this._setMute(true);
-}
-
-/**
- * Unmutes the stream.
- */
-JitsiTrack.prototype.unmute = function () {
-    this._setMute(false);
-}
-
 /**
  * Attaches the MediaStream of this track to an HTML container.
  * Adds the container to the list of containers that are displaying the track.

modules/RTC/RTC.js

 /**
  * Set mute for all local audio streams attached to the conference.
  * @param value the mute value
+ * @returns {Promise}
  */
 RTC.prototype.setAudioMute = function (value) {
+    var mutes = [];
     for(var i = 0; i < this.localStreams.length; i++) {
         var stream = this.localStreams[i];
         if(stream.getType() !== "audio") {
             continue;
         }
-        stream._setMute(value);
+        // this is a Promise
+        mutes.push(stream.mute(value));
     }
+    // we return a Promise from all Promises so we can wait for their execution
+    return Promise.all(mutes);
 }
 
 RTC.prototype.removeLocalStream = function (stream) {