feat: add config.startWithAudioMuted config.startWithVideoMuted

conference.js

      * on.
      * @param {boolean} options.startScreenSharing=false - if <tt>true</tt>
      * should start with screensharing instead of camera video.
+     * @param {boolean} options.startWithAudioMuted - will start the conference
+     * without any audio tracks.
+     * @param {boolean} options.startWithVideoMuted - will start the conference
+     * without any video tracks.
      * @returns {Promise.<JitsiLocalTrack[], JitsiConnection>}
      */
     createInitialLocalTracksAndConnect(roomName, options = {}) {
             audioOnlyError,
             screenSharingError,
             videoOnlyError;
+        const initialDevices = [];
+        let requestedAudio = false;
+        let requestedVideo = false;
+
+        if (!options.startWithAudioMuted) {
+            initialDevices.push('audio');
+            requestedAudio = true;
+        }
+        if (!options.startWithVideoMuted
+                && !options.startAudioOnly
+                && !options.startScreenSharing) {
+            initialDevices.push('video');
+            requestedVideo = true;
+        }
 
         JitsiMeetJS.mediaDevices.addEventListener(
             JitsiMeetJS.events.mediaDevices.PERMISSION_PROMPT_IS_SHOWN,
                     mediaPermissionPromptVisibilityChanged(true, browser))
         );
 
-        // First try to retrieve both audio and video.
         let tryCreateLocalTracks;
 
-        // FIXME the logic about trying to go audio only on error is duplicated
-        if (options.startAudioOnly) {
-            tryCreateLocalTracks
-                = createLocalTracks({ devices: ['audio'] }, true)
-                    .catch(err => {
-                        audioOnlyError = err;
-
-                        return [];
-                    });
+        // Enable audio only mode
+        if (config.startAudioOnly) {
+            APP.store.dispatch(toggleAudioOnly());
+        }
 
-            // Enable audio only mode
-            if (config.startAudioOnly) {
-                APP.store.dispatch(toggleAudioOnly());
-            }
-        } else if (options.startScreenSharing) {
+        // FIXME is there any simpler way to rewrite this spaghetti below ?
+        if (options.startScreenSharing) {
             tryCreateLocalTracks = this._createDesktopTrack()
                 .then(desktopStream => {
+                    if (!requestedAudio) {
+                        return [desktopStream];
+                    }
+
                     return createLocalTracks({ devices: ['audio'] }, true)
                         .then(([audioStream]) => {
                             return [desktopStream, audioStream];
                 }).catch(error => {
                     logger.error('Failed to obtain desktop stream', error);
                     screenSharingError = error;
-                    return createLocalTracks({ devices: ['audio'] }, true);
+                    return requestedAudio
+                        ? createLocalTracks({ devices: ['audio'] }, true)
+                        : [];
                 }).catch(error => {
                     audioOnlyError = error;
                     return [];
                 });
+        } else if (!requestedAudio && !requestedVideo) {
+            // Resolve with no tracks
+            tryCreateLocalTracks = Promise.resolve([]);
         } else {
             tryCreateLocalTracks = createLocalTracks(
-                {devices: ['audio', 'video']}, true)
-                .catch(err => {
-                    // If failed then try to retrieve only audio.
-                    audioAndVideoError = err;
-                    return createLocalTracks({devices: ['audio']}, true);
-                })
+                { devices: initialDevices }, true)
                 .catch(err => {
+                    if (requestedAudio && requestedVideo) {
+
+                        // Try audio only...
+                        audioAndVideoError = err;
+
+                        return createLocalTracks({devices: ['audio']}, true);
+                    } else if (requestedAudio && !requestedVideo) {
+                        audioOnlyError = err;
+
+                        return [];
+                    } else if (requestedVideo && !requestedAudio) {
+                        videoOnlyError = err;
+
+                        return [];
+                    }
+                    logger.error('Should never happen');
+                }).catch(err => {
+                    // Log this just in case...
+                    if (!requestedAudio) {
+                        logger.error('The impossible just happened', err);
+                    }
                     audioOnlyError = err;
 
                     // Try video only...
-                    return createLocalTracks({devices: ['video']}, true);
+                    return requestedVideo
+                        ? createLocalTracks({devices: ['video']}, true)
+                        : [];
                 })
                 .catch(err => {
+                    // Log this just in case...
+                    if (!requestedVideo) {
+                        logger.error('The impossible just happened', err);
+                    }
                     videoOnlyError = err;
 
                     return [];
                 return this.createInitialLocalTracksAndConnect(
                     options.roomName, {
                         startAudioOnly: config.startAudioOnly,
-                        startScreenSharing: config.startScreenSharing
+                        startScreenSharing: config.startScreenSharing,
+                        startWithAudioMuted: config.startWithAudioMuted,
+                        startWithVideoMuted: config.startWithVideoMuted,
                     });
             }).then(([tracks, con]) => {
                 tracks.forEach(track => {

config.js

     startScreenSharing: false, // Will try to start with screensharing instead of camera
 //    startAudioMuted: 10, // every participant after the Nth will start audio muted
 //    startVideoMuted: 10, // every participant after the Nth will start video muted
+    startWithAudioMuted: false, // will start with the microphone muted
+    startWithVideoMuted: false, // will start with the camera turned off
 //    defaultLanguage: "en",
 // To enable sending statistics to callstats.io you should provide Applicaiton ID and Secret.
 //    callStatsID: "", // Application ID for callstats.io API