feat(RTC): Signal video type and availability to bridge.

JitsiConference.js

             if (oldTrack) {
                 this.onLocalTrackRemoved(oldTrack);
             }
+
+            // Send 'VideoTypeMessage' on the bridge channel for the new track.
             if (newTrack) {
-                // Now handle the addition of the newTrack at the
-                // JitsiConference level
+                // Now handle the addition of the newTrack at the JitsiConference level
                 this._setupNewTrack(newTrack);
+                newTrack.isVideoTrack() && this.rtc.setVideoType(newTrack.videoType);
+            } else {
+                oldTrack && oldTrack.isVideoTrack() && this.rtc.setVideoType(VideoType.NONE);
             }
 
             return Promise.resolve();
     if (this.jvbJingleSession) {
         addAsUnmutePromises.push(this.jvbJingleSession.addTrackAsUnmute(track));
     } else {
-        logger.info(
-            'Add local MediaStream as unmute -'
-                + ' no JVB Jingle session started yet');
+        logger.debug('Add local MediaStream as unmute - no JVB Jingle session started yet');
     }
 
     if (this.p2pJingleSession) {
         addAsUnmutePromises.push(this.p2pJingleSession.addTrackAsUnmute(track));
     } else {
-        logger.info(
-            'Add local MediaStream as unmute -'
-                + ' no P2P Jingle session started yet');
+        logger.debug('Add local MediaStream as unmute - no P2P Jingle session started yet');
     }
 
-    return Promise.all(addAsUnmutePromises);
+    return Promise.allSettled(addAsUnmutePromises)
+        .then(() => {
+            // Signal the video type to the bridge.
+            track.isVideoTrack() && this.rtc.setVideoType(track.videoType);
+        });
 };
 
 /**
     const removeAsMutePromises = [];
 
     if (this.jvbJingleSession) {
-        removeAsMutePromises.push(
-            this.jvbJingleSession.removeTrackAsMute(track));
+        removeAsMutePromises.push(this.jvbJingleSession.removeTrackAsMute(track));
     } else {
-        logger.info(
-            'Remove local MediaStream - no JVB JingleSession started yet');
+        logger.debug('Remove local MediaStream - no JVB JingleSession started yet');
     }
     if (this.p2pJingleSession) {
-        removeAsMutePromises.push(
-            this.p2pJingleSession.removeTrackAsMute(track));
+        removeAsMutePromises.push(this.p2pJingleSession.removeTrackAsMute(track));
     } else {
-        logger.info(
-            'Remove local MediaStream - no P2P JingleSession started yet');
+        logger.debug('Remove local MediaStream - no P2P JingleSession started yet');
     }
 
-    return Promise.all(removeAsMutePromises);
+    return Promise.allSettled(removeAsMutePromises)
+        .then(() => {
+            // Signal the video type to the bridge.
+            track.isVideoTrack() && this.rtc.setVideoType(VideoType.NONE);
+        });
 };
 
 /**

modules/RTC/BridgeChannel.js

         });
     }
 
+    /**
+     * Sends a 'VideoTypeMessage' message via the bridge channel.
+     *
+     * @param {string} videoType 'camera', 'desktop' or 'none'.
+     */
+    sendVideoTypeMessage(videoType) {
+        logger.debug(`Sending VideoTypeMessage with video type as ${videoType}`);
+        this._send({
+            colibriClass: 'VideoTypeMessage',
+            videoType
+        });
+    }
+
     /**
      * Set events on the given RTCDataChannel or WebSocket instance.
      */

modules/RTC/RTC.js

         this._updateAudioOutputForAudioTracks
             = this._updateAudioOutputForAudioTracks.bind(this);
 
+        // The default video type assumed by the bridge.
+        this._videoType = VideoType.CAMERA;
+
         // Switch audio output device on all remote audio tracks. Local audio
         // tracks handle this event by themselves.
         if (RTCUtils.isDeviceChangeAvailable('output')) {
                 }
             }
 
+            try {
+                this._channel.sendVideoTypeMessage(this._videoType);
+            } catch (error) {
+                GlobalOnErrorHandler.callErrorHandler(error);
+                logger.error(`Cannot send VideoTypeMessage ${this._videoType}`, error);
+            }
+
             this.removeListener(RTCEvents.DATA_CHANNEL_OPEN, this._channelOpenListener);
             this._channelOpenListener = null;
         };
         }
     }
 
+    /**
+     * Sets the video type and availability for the local video source.
+     *
+     * @param {string} videoType 'camera' for camera, 'desktop' for screenshare and
+     * 'none' for when local video source is muted or removed from the peerconnection.
+     * @returns {void}
+     */
+    setVideoType(videoType) {
+        if (this._videoType !== videoType) {
+            this._videoType = videoType;
+
+            if (this._channel && this._channel.isOpen()) {
+                this._channel.sendVideoTypeMessage(videoType);
+            }
+        }
+    }
+
     /**
      * Elects the participants with the given ids to be the selected
      * participants in order to always receive video for this participant (even

service/RTC/VideoType.js

 /* global module */
 /**
  * Enumeration of the video types
- * @type {{CAMERA: string, DESKTOP: string}}
+ * @type {{CAMERA: string, DESKTOP: string, NONE: string}}
  */
 const VideoType = {
     /**
     /**
      * The desktop video type.
      */
-    DESKTOP: 'desktop'
+    DESKTOP: 'desktop',
+
+    /**
+     * No local video source.
+     */
+    NONE: 'none'
 };
 
 module.exports = VideoType;