Turns off the camera when video is muted on https connection.

index.html

     <script src="libs/popover.js?v=1"></script><!-- bootstrap tooltip lib -->
     <script src="libs/toastr.js?v=1"></script><!-- notifications lib -->
     <script src="interface_config.js?v=5"></script>
-    <script src="libs/app.bundle.js?v=43"></script>
+    <script src="libs/app.bundle.js?v=44"></script>
     <script src="analytics.js?v=1"></script><!-- google analytics plugin -->
     <link rel="stylesheet" href="css/font.css?v=6"/>
     <link rel="stylesheet" href="css/toastr.css?v=1">

modules/RTC/LocalStream.js

 var StreamEventTypes = require("../../service/RTC/StreamEventTypes.js");
 
+
 function LocalStream(stream, type, eventEmitter, videoType)
 {
     this.stream = stream;
 
 LocalStream.prototype.setMute = function(mute)
 {
-    var tracks = this.getTracks();
 
-    for (var idx = 0; idx < tracks.length; idx++) {
-        tracks[idx].enabled = mute;
+    if(window.location.protocol != "https:" ||
+        this.isAudioStream() || this.videoType === "screen")
+    {
+        var tracks = this.getTracks();
+
+        for (var idx = 0; idx < tracks.length; idx++) {
+            tracks[idx].enabled = mute;
+        }
+    }
+    else
+    {
+        if(mute === false) {
+            APP.xmpp.removeStream(this.stream);
+            this.stream.stop();
+        }
+        else
+        {
+            APP.RTC.rtcUtils.obtainAudioAndVideoPermissions(["video"],
+                function (stream) {
+                    APP.RTC.changeLocalVideo(stream, false, function () {});
+                });
+        }
     }
 };
 
     }
     else
     {
+        if(this.stream.ended)
+            return true;
         tracks = this.stream.getVideoTracks();
     }
     for (var idx = 0; idx < tracks.length; idx++) {
     return this.stream.getTracks()[0].id;
 }
 
-
-
 module.exports = LocalStream;

modules/RTC/RTC.js

     changeLocalVideo: function (stream, isUsingScreenStream, callback) {
         var oldStream = this.localVideo.getOriginalStream();
         var type = (isUsingScreenStream? "screen" : "video");
+        var localCallback = callback;
+        if(this.localVideo.isMuted() && this.localVideo.videoType !== type)
+        {
+            localCallback = function() {
+                APP.xmpp.setVideoMute(false, APP.UI.setVideoMuteButtonsState);
+                callback();
+            };
+        }
         this.localVideo = this.createLocalStream(stream, "video", true, type);
         // Stop the stream to trigger onended event for old stream
         oldStream.stop();
-        APP.xmpp.switchStreams(stream, oldStream,callback);
+        APP.xmpp.switchStreams(stream, oldStream,localCallback);
     },
     /**
      * Checks if video identified by given src is desktop stream.
             isDesktop = (stream.videoType === "screen");
 
         return isDesktop;
+    },
+    setVideoMute: function(mute, callback, options) {
+        if(!this.localVideo)
+            return;
+
+        if (mute == APP.RTC.localVideo.isMuted())
+        {
+            APP.xmpp.sendVideoInfoPresence(mute);
+            if(callback)
+                callback();
+        }
+        else
+        {
+            APP.RTC.localVideo.setMute(!mute);
+            APP.xmpp.setVideoMute(
+                mute,
+                callback,
+                options);
+        }
     }
 };
 

modules/RTC/RTCUtils.js

  * We ask for audio and video combined stream in order to get permissions and
  * not to ask twice.
  */
-RTCUtils.prototype.obtainAudioAndVideoPermissions = function() {
+RTCUtils.prototype.obtainAudioAndVideoPermissions = function(devices, callback) {
     var self = this;
     // Get AV
 
+    if(!devices)
+        devices = ['audio', 'video'];
+
     this.getUserMediaWithConstraints(
-        ['audio', 'video'],
+        devices,
         function (stream) {
-            self.successCallback(stream);
+            if(callback)
+                callback(stream);
+            else
+                self.successCallback(stream);
         },
         function (error) {
             self.errorCallback(error);
 
 };
 
-
-
 module.exports = RTCUtils;

modules/UI/UI.js

  * contrast to an automatic decision taken by the application logic)
  */
 function setVideoMute(mute, options) {
-    APP.xmpp.setVideoMute(
-        mute,
-        function (mute) {
-            var video = $('#video');
-            var communicativeClass = "icon-camera";
-            var muteClass = "icon-camera icon-camera-disabled";
-
-            if (mute) {
-                video.removeClass(communicativeClass);
-                video.addClass(muteClass);
-            } else {
-                video.removeClass(muteClass);
-                video.addClass(communicativeClass);
-            }
-        },
+    APP.RTC.setVideoMute(mute,
+        UI.setVideoMuteButtonsState,
         options);
 }
 
     return ToolbarToggler.dockToolbar(isDock);
 }
 
+UI.setVideoMuteButtonsState = function (mute) {
+    var video = $('#video');
+    var communicativeClass = "icon-camera";
+    var muteClass = "icon-camera icon-camera-disabled";
+
+    if (mute) {
+        video.removeClass(communicativeClass);
+        video.addClass(muteClass);
+    } else {
+        video.removeClass(muteClass);
+        video.addClass(communicativeClass);
+    }
+}
+
 module.exports = UI;
 

modules/xmpp/JingleSession.js

     }
 };
 
-/**
- * Determines whether the (local) video is mute i.e. all video tracks are
- * disabled.
- *
- * @return <tt>true</tt> if the (local) video is mute i.e. all video tracks are
- * disabled; otherwise, <tt>false</tt>
- */
-JingleSession.prototype.isVideoMute = function () {
-    var tracks = APP.RTC.localVideo.getVideoTracks();
-    var mute = true;
-
-    for (var i = 0; i < tracks.length; ++i) {
-        if (tracks[i].enabled) {
-            mute = false;
-            break;
-        }
-    }
-    return mute;
-};
-
 /**
  * Mutes/unmutes the (local) video i.e. enables/disables all video tracks.
  *
     this.modifySources(callback(mute));
 };
 
-// SDP-based mute by going recvonly/sendrecv
-// FIXME: should probably black out the screen as well
-JingleSession.prototype.toggleVideoMute = function (callback) {
-    this.service.setVideoMute(APP.RTC.localVideo.isMuted(), callback);
-};
-
 JingleSession.prototype.hardMuteVideo = function (muted) {
     this.pendingop = muted ? 'mute' : 'unmute';
 };

modules/xmpp/xmpp.js

             // FIXME: probably removing streams is not required and close() should
             // be enough
             if (APP.RTC.localAudio) {
-                handler.peerconnection.removeStream(APP.RTC.localAudio.getOriginalStream(), onUnload);
+                handler.peerconnection.removeStream(
+                    APP.RTC.localAudio.getOriginalStream(), onUnload);
             }
             if (APP.RTC.localVideo) {
-                handler.peerconnection.removeStream(APP.RTC.localVideo.getOriginalStream(), onUnload);
+                handler.peerconnection.removeStream(
+                    APP.RTC.localVideo.getOriginalStream(), onUnload);
             }
             handler.peerconnection.close();
         }
             callback();
         }
     },
+    sendVideoInfoPresence: function (mute) {
+        connection.emuc.addVideoInfoToPresence(mute);
+        connection.emuc.sendPresence();
+    },
     setVideoMute: function (mute, callback, options) {
-        if(!connection || !APP.RTC.localVideo)
+        if(!connection)
             return;
-
+        var self = this;
         var localCallback = function (mute) {
-            connection.emuc.addVideoInfoToPresence(mute);
-            connection.emuc.sendPresence();
+            self.sendVideoInfoPresence(mute);
             return callback(mute);
         };
 
-        if (mute == APP.RTC.localVideo.isMuted())
+        if(connection.jingle.activecall)
         {
-            // Even if no change occurs, the specified callback is to be executed.
-            // The specified callback may, optionally, return a successCallback
-            // which is to be executed as well.
-            var successCallback = localCallback(mute);
-
-            if (successCallback) {
-                successCallback();
-            }
-        } else {
-            APP.RTC.localVideo.setMute(!mute);
-            if(connection.jingle.activecall)
-            {
-                connection.jingle.activecall.setVideoMute(
-                    mute, localCallback, options);
-            }
-            else {
-                localCallback(mute);
-            }
-
+            connection.jingle.activecall.setVideoMute(
+                mute, localCallback, options);
+        }
+        else {
+            localCallback(mute);
         }
+
     },
     setAudioMute: function (mute, callback) {
         if (!(connection && APP.RTC.localAudio)) {
     },
     getSessions: function () {
         return connection.jingle.sessions;
+    },
+    removeStream: function (stream) {
+        if(!connection || !connection.jingle.activecall ||
+            !connection.jingle.activecall.peerconnection)
+            return;
+        connection.jingle.activecall.peerconnection.removeStream(stream);
     }
-
 };
 
 module.exports = XMPP;