Move most of the logic to C++ model, speed up initialization. Reduce number of AudioClient blocking calls to minimum

interface/resources/qml/hifi/Audio.qml

@@ -162,7 +162,6 @@ Rectangle {
                     onCheckBoxClicked: {
                         if (checked) {
                             AudioDevice.setInputDeviceAsync(devicename)
-                            Settings.setValue("audio_input_device", devicename);
                         }
                     }
                 }
@@ -219,7 +218,6 @@ Rectangle {
                     onCheckBoxClicked: {
                         if (checked) {
                             AudioDevice.setOutputDeviceAsync(devicename)
-                            Settings.setValue("audio_output_device", devicename);
                         }
                     }
                 }

interface/src/scripting/AudioDeviceScriptingInterface.cpp

@@ -11,21 +11,19 @@
 
 #include "AudioClient.h"
 #include "AudioDeviceScriptingInterface.h"
-
+#include "SettingsScriptingInterface.h"
 
 AudioDeviceScriptingInterface* AudioDeviceScriptingInterface::getInstance() {
     static AudioDeviceScriptingInterface sharedInstance;
     return &sharedInstance;
 }
 
-QStringList AudioDeviceScriptingInterface::inputAudioDevices() const
+QStringList AudioDeviceScriptingInterface::inputAudioDevices() const {
-{
+    return _inputAudioDevices;
-    return DependencyManager::get<AudioClient>()->getDeviceNames(QAudio::AudioInput).toList();;
 }
 
-QStringList AudioDeviceScriptingInterface::outputAudioDevices() const
+QStringList AudioDeviceScriptingInterface::outputAudioDevices() const {
-{
+    return _outputAudioDevices;
-    return DependencyManager::get<AudioClient>()->getDeviceNames(QAudio::AudioOutput).toList();;
 }
 
 bool AudioDeviceScriptingInterface::muted()
@@ -44,6 +42,16 @@ AudioDeviceScriptingInterface::AudioDeviceScriptingInterface(): QAbstractListMod
         this, &AudioDeviceScriptingInterface::onCurrentOutputDeviceChanged, Qt::QueuedConnection);
     //fill up model
     onDeviceChanged();
+    //set up previously saved device
+    SettingsScriptingInterface *settings = SettingsScriptingInterface::getInstance();
+    const QString inDevice = settings->getValue("audio_input_device").toString();
+    if (inDevice != _currentInputDevice) {
+        setInputDeviceAsync(inDevice);
+    }
+    const QString outDevice = settings->getValue("audio_output_device").toString();
+    if (outDevice != _currentOutputDevice) {
+        setOutputDeviceAsync(outDevice);
+    }
 }
 
 bool AudioDeviceScriptingInterface::setInputDevice(const QString& deviceName) {
@@ -64,6 +72,31 @@ bool AudioDeviceScriptingInterface::setOutputDevice(const QString& deviceName) {
     return result;
 }
 
+bool AudioDeviceScriptingInterface::setDeviceFromMenu(const QString &deviceMenuName) {
+    QAudio::Mode mode;
+
+    if (deviceMenuName.indexOf("for Output") != -1) {
+        mode = QAudio::AudioOutput;
+    } else if (deviceMenuName.indexOf("for Input") != -1) {
+        mode = QAudio::AudioInput;
+    } else {
+        return false;
+    }
+
+    for (ScriptingAudioDeviceInfo di: _devices) {
+        if (mode == di.mode && deviceMenuName.contains(di.name)) {
+            if (mode == QAudio::AudioOutput) {
+                setOutputDeviceAsync(di.name);
+            } else {
+                setInputDeviceAsync(di.name);
+            }
+            return true;
+        }
+    }
+
+    return false;
+}
+
 void AudioDeviceScriptingInterface::setInputDeviceAsync(const QString& deviceName) {
     QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "switchInputToAudioDevice",
                               Qt::QueuedConnection,
@@ -167,38 +200,51 @@ QHash<int, QByteArray> AudioDeviceScriptingInterface::roleNames() const {
 void AudioDeviceScriptingInterface::onDeviceChanged()
 {
     beginResetModel();
+    _outputAudioDevices.clear();
     _devices.clear();
-    const QString &outDevice = getOutputDevice();
+    _currentOutputDevice = getOutputDevice();
     for (QString name: getOutputDevices()) {
-        AudioDeviceInfo di;
+        ScriptingAudioDeviceInfo di;
         di.name = name;
-        di.selected = (name == outDevice);
+        di.selected = (name == _currentOutputDevice);
         di.mode = QAudio::AudioOutput;
         _devices.append(di);
+        _outputAudioDevices.append(name);
     }
-    const QString &inDevice = getInputDevice();
+    emit outputAudioDevicesChanged(_outputAudioDevices);
+
+    _inputAudioDevices.clear();
+    _currentInputDevice = getInputDevice();
     for (QString name: getInputDevices()) {
-        AudioDeviceInfo di;
+        ScriptingAudioDeviceInfo di;
         di.name = name;
-        di.selected = (name == inDevice);
+        di.selected = (name == _currentInputDevice);
         di.mode = QAudio::AudioInput;
         _devices.append(di);
+        _inputAudioDevices.append(name);
     }
+    emit inputAudioDevicesChanged(_inputAudioDevices);
 
     endResetModel();
     emit deviceChanged();
 }
 
-void AudioDeviceScriptingInterface::onCurrentInputDeviceChanged()
+void AudioDeviceScriptingInterface::onCurrentInputDeviceChanged(const QString &name)
 {
-    currentDeviceUpdate(getInputDevice(), QAudio::AudioInput);
+    currentDeviceUpdate(name, QAudio::AudioInput);
-    emit currentInputDeviceChanged();
+    //we got a signal that device changed. Save it now
+    SettingsScriptingInterface *settings = SettingsScriptingInterface::getInstance();
+    settings->setValue("audio_input_device", name);
+    emit currentInputDeviceChanged(name);
 }
 
-void AudioDeviceScriptingInterface::onCurrentOutputDeviceChanged()
+void AudioDeviceScriptingInterface::onCurrentOutputDeviceChanged(const QString &name)
 {
-    currentDeviceUpdate(getOutputDevice(), QAudio::AudioOutput);
+    currentDeviceUpdate(name, QAudio::AudioOutput);
-    emit currentOutputDeviceChanged();
+    //we got a signal that device changed. Save it now
+    SettingsScriptingInterface *settings = SettingsScriptingInterface::getInstance();
+    settings->setValue("audio_output_device", name);
+    emit currentOutputDeviceChanged(name);
 }
 
 void AudioDeviceScriptingInterface::currentDeviceUpdate(const QString &name, QAudio::Mode mode)
@@ -207,7 +253,7 @@ void AudioDeviceScriptingInterface::currentDeviceUpdate(const QString &name, QAu
     role.append(SelectedRole);
 
     for (int i = 0; i < _devices.size(); i++) {
-        AudioDeviceInfo di = _devices.at(i);
+        ScriptingAudioDeviceInfo di = _devices.at(i);
         if (di.mode != mode)
             continue;
         if (di.selected && di.name != name ) {

interface/src/scripting/AudioDeviceScriptingInterface.h

@@ -20,7 +20,7 @@
 
 class AudioEffectOptions;
 
-struct AudioDeviceInfo {
+struct ScriptingAudioDeviceInfo {
     QString name;
     bool selected;
     QAudio::Mode mode;
@@ -52,13 +52,14 @@ public:
 
 private slots:
     void onDeviceChanged();
-    void onCurrentInputDeviceChanged();
+    void onCurrentInputDeviceChanged(const QString &name);
-    void onCurrentOutputDeviceChanged();
+    void onCurrentOutputDeviceChanged(const QString &name);
     void currentDeviceUpdate(const QString &name, QAudio::Mode mode);
 
 public slots:
     bool setInputDevice(const QString& deviceName);
     bool setOutputDevice(const QString& deviceName);
+    bool setDeviceFromMenu(const QString& deviceMenuName);
 
     QString getInputDevice();
     QString getOutputDevice();
@@ -87,14 +88,20 @@ private:
 signals:
     void muteToggled();
     void deviceChanged();
-    void currentInputDeviceChanged();
+    void currentInputDeviceChanged(const QString &name);
-    void currentOutputDeviceChanged();
+    void currentOutputDeviceChanged(const QString &name);
     void mutedChanged(bool muted);
     void inputAudioDevicesChanged(QStringList inputAudioDevices);
     void outputAudioDevicesChanged(QStringList outputAudioDevices);
 
 private:
-    QVector<AudioDeviceInfo> _devices;
+    QVector<ScriptingAudioDeviceInfo> _devices;
+
+    QStringList _inputAudioDevices;
+    QStringList _outputAudioDevices;
+
+    QString _currentInputDevice;
+    QString _currentOutputDevice;
 };
 
 #endif // hifi_AudioDeviceScriptingInterface_h

libraries/audio-client/src/AudioClient.cpp

@@ -1375,7 +1375,7 @@ bool AudioClient::switchInputToAudioDevice(const QAudioDeviceInfo& inputDeviceIn
     if (!inputDeviceInfo.isNull()) {
         qCDebug(audioclient) << "The audio input device " << inputDeviceInfo.deviceName() << "is available.";
         _inputAudioDeviceName = inputDeviceInfo.deviceName().trimmed();
-        emit currentInputDeviceChanged();
+        emit currentInputDeviceChanged(_inputAudioDeviceName);
 
         if (adjustedFormatForAudioDevice(inputDeviceInfo, _desiredInputFormat, _inputFormat)) {
             qCDebug(audioclient) << "The format to be used for audio input is" << _inputFormat;
@@ -1493,7 +1493,7 @@ bool AudioClient::switchOutputToAudioDevice(const QAudioDeviceInfo& outputDevice
     if (!outputDeviceInfo.isNull()) {
         qCDebug(audioclient) << "The audio output device " << outputDeviceInfo.deviceName() << "is available.";
         _outputAudioDeviceName = outputDeviceInfo.deviceName().trimmed();
-        emit currentOutputDeviceChanged();
+        emit currentOutputDeviceChanged(_outputAudioDeviceName);
 
         if (adjustedFormatForAudioDevice(outputDeviceInfo, _desiredOutputFormat, _outputFormat)) {
             qCDebug(audioclient) << "The format to be used for audio output is" << _outputFormat;

libraries/audio-client/src/AudioClient.h

@@ -238,8 +238,8 @@ signals:
 
     void muteEnvironmentRequested(glm::vec3 position, float radius);
 
-    void currentOutputDeviceChanged();
+    void currentOutputDeviceChanged(const QString &name);
-    void currentInputDeviceChanged();
+    void currentInputDeviceChanged(const QString &name);
 
 protected:
     AudioClient();

libraries/script-engine/src/AudioScriptingInterface.h

@@ -24,6 +24,7 @@ class AudioScriptingInterface : public QObject, public Dependency {
     SINGLETON_DEPENDENCY
 
 public:
+        virtual ~AudioScriptingInterface() {}
     void setLocalAudioInterface(AbstractAudioInterface* audioInterface) { _localAudioInterface = audioInterface; }
 
 protected:

scripts/system/selectAudioDevice.js

@@ -17,18 +17,6 @@
 
 const INPUT = "Input";
 const OUTPUT = "Output";
-function parseMenuItem(item) {
-	const USE = "Use ";
-	const FOR_INPUT = " for " + INPUT;
-	const FOR_OUTPUT = " for " + OUTPUT;
-	if (item.slice(0, USE.length) == USE) {
-		if (item.slice(-FOR_INPUT.length) == FOR_INPUT) {
-			return { device: item.slice(USE.length, -FOR_INPUT.length), mode: INPUT };
-		} else if (item.slice(-FOR_OUTPUT.length) == FOR_OUTPUT) {
-			return { device: item.slice(USE.length, -FOR_OUTPUT.length), mode: OUTPUT };
-		}
-	}
-}
 
 //
 // VAR DEFINITIONS
@@ -36,13 +24,15 @@ function parseMenuItem(item) {
 var debugPrintStatements = true;
 const INPUT_DEVICE_SETTING = "audio_input_device";
 const OUTPUT_DEVICE_SETTING = "audio_output_device";
-var audioDevicesList = [];
+var audioDevicesList = []; // placeholder for menu items
 var wasHmdActive = false; // assume it's not active to start
 var switchedAudioInputToHMD = false;
 var switchedAudioOutputToHMD = false;
 var previousSelectedInputAudioDevice = "";
 var previousSelectedOutputAudioDevice = "";
-var skipMenuEvents = true;
+
+var interfaceInputDevice = "";
+var interfaceOutputDevice = "";
 
 //
 // BEGIN FUNCTION DEFINITIONS
@@ -56,58 +46,37 @@ function debug() {
 
 function setupAudioMenus() {
     // menu events can be triggered asynchronously; skip them for 200ms to avoid recursion and false switches
-    skipMenuEvents = true;
-    Script.setTimeout(function() { skipMenuEvents = false; }, 200);
-
     removeAudioMenus();
 
     // Setup audio input devices
     Menu.addSeparator("Audio", "Input Audio Device");
-    var inputDevices = AudioDevice.getInputDevices();
     var currentInputDevice = AudioDevice.getInputDevice()
-    for (var i = 0; i < inputDevices.length; i++) {
+    for (var i = 0; i < AudioDevice.inputAudioDevices.length; i++) {
-        var audioDeviceMenuString = "Use " + inputDevices[i] + " for Input";
+        var audioDeviceMenuString = "Use " + AudioDevice.inputAudioDevices[i] + " for Input";
         Menu.addMenuItem({
             menuName: "Audio",
             menuItemName: audioDeviceMenuString,
             isCheckable: true,
-            isChecked: inputDevices[i] == currentInputDevice
+            isChecked: AudioDevice.inputAudioDevices[i] == currentInputDevice
         });
         audioDevicesList.push(audioDeviceMenuString);
     }
 
     // Setup audio output devices
     Menu.addSeparator("Audio", "Output Audio Device");
-    var outputDevices = AudioDevice.getOutputDevices();
     var currentOutputDevice = AudioDevice.getOutputDevice()
-    for (var i = 0; i < outputDevices.length; i++) {
+    for (var i = 0; i < AudioDevice.outputAudioDevices.length; i++) {
-        var audioDeviceMenuString = "Use " + outputDevices[i] + " for Output";
+        var audioDeviceMenuString = "Use " + AudioDevice.outputAudioDevices[i] + " for Output";
         Menu.addMenuItem({
             menuName: "Audio",
             menuItemName: audioDeviceMenuString,
             isCheckable: true,
-            isChecked: outputDevices[i] == currentOutputDevice
+            isChecked: AudioDevice.outputAudioDevices[i] == currentOutputDevice
         });
         audioDevicesList.push(audioDeviceMenuString);
     }
 }
 
-function checkDeviceMismatch() {
-    var inputDeviceSetting = Settings.getValue(INPUT_DEVICE_SETTING);
-    var interfaceInputDevice = AudioDevice.getInputDevice();
-    if (interfaceInputDevice != inputDeviceSetting) {
-        debug("Input Setting & Device mismatch! Input SETTING: " + inputDeviceSetting + "Input DEVICE IN USE: " + interfaceInputDevice);
-        switchAudioDevice("Use " + inputDeviceSetting + " for Input");
-    }
-
-    var outputDeviceSetting = Settings.getValue(OUTPUT_DEVICE_SETTING);
-    var interfaceOutputDevice = AudioDevice.getOutputDevice();
-    if (interfaceOutputDevice != outputDeviceSetting) {
-        debug("Output Setting & Device mismatch! Output SETTING: " + outputDeviceSetting + "Output DEVICE IN USE: " + interfaceOutputDevice);
-        switchAudioDevice("Use " + outputDeviceSetting + " for Output");
-    }
-}
-
 function removeAudioMenus() {
     Menu.removeSeparator("Audio", "Input Audio Device");
     Menu.removeSeparator("Audio", "Output Audio Device");
@@ -126,94 +95,41 @@ function removeAudioMenus() {
 function onDevicechanged() {
     debug("System audio devices changed. Removing and replacing Audio Menus...");
     setupAudioMenus();
-    checkDeviceMismatch();
 }
 
 function onMenuEvent(audioDeviceMenuString) {
-    if (!skipMenuEvents) {
+    if (Menu.isOptionChecked(audioDeviceMenuString) &&
-        switchAudioDevice(audioDeviceMenuString);
+            (audioDeviceMenuString !== interfaceInputDevice &&
+             audioDeviceMenuString !== interfaceOutputDevice)) {
+        AudioDevice.setDeviceFromMenu(audioDeviceMenuString)
     }
 }
 
 function onCurrentDeviceChanged() {
     debug("System audio device switched. ");
-    var interfaceInputDevice = "Use " + AudioDevice.getInputDevice() + " for Input";
+    interfaceInputDevice = "Use " + AudioDevice.getInputDevice() + " for Input";
-    var interfaceOutputDevice = "Use " + AudioDevice.getOutputDevice() + " for Output";
+    interfaceOutputDevice = "Use " + AudioDevice.getOutputDevice() + " for Output";
     for (var index = 0; index < audioDevicesList.length; index++) {
         if (audioDevicesList[index] === interfaceInputDevice ||
                 audioDevicesList[index] === interfaceOutputDevice) {
+            if (Menu.isOptionChecked(audioDevicesList[index]) === false)
                 Menu.setIsOptionChecked(audioDevicesList[index], true);
         } else {
+            if (Menu.isOptionChecked(audioDevicesList[index]) === true)
                 Menu.setIsOptionChecked(audioDevicesList[index], false);
         }
     }
 }
 
-function switchAudioDevice(audioDeviceMenuString) {
-    // if the device is not plugged in, short-circuit
-    if (!~audioDevicesList.indexOf(audioDeviceMenuString)) {
-        return;
-    }
-
-    var selection = parseMenuItem(audioDeviceMenuString);
-    if (!selection) {
-        debug("Invalid Audio audioDeviceMenuString! Doesn't end with 'for Input' or 'for Output'");
-        return;
-    }
-
-    // menu events can be triggered asynchronously; skip them for 200ms to avoid recursion and false switches
-    skipMenuEvents = true;
-    Script.setTimeout(function() { skipMenuEvents = false; }, 200);
-
-    var selectedDevice = selection.device;
-    if (selection.mode == INPUT) {
-        var currentInputDevice = AudioDevice.getInputDevice();
-        if (selectedDevice != currentInputDevice) {
-            debug("Switching audio INPUT device from " + currentInputDevice + " to " + selectedDevice);
-            Menu.setIsOptionChecked("Use " + currentInputDevice + " for Input", false);
-            if (AudioDevice.setInputDevice(selectedDevice)) {
-                Settings.setValue(INPUT_DEVICE_SETTING, selectedDevice);
-                Menu.setIsOptionChecked(audioDeviceMenuString, true);
-            } else {
-                debug("Error setting audio input device!")
-                Menu.setIsOptionChecked(audioDeviceMenuString, false);
-            }
-        } else {
-            debug("Selected input device is the same as the current input device!")
-            Settings.setValue(INPUT_DEVICE_SETTING, selectedDevice);
-            Menu.setIsOptionChecked(audioDeviceMenuString, true);
-            AudioDevice.setInputDevice(selectedDevice); // Still try to force-set the device (in case the user's trying to forcefully debug an issue)
-        }
-    } else if (selection.mode == OUTPUT) {
-        var currentOutputDevice = AudioDevice.getOutputDevice();
-        if (selectedDevice != currentOutputDevice) {
-            debug("Switching audio OUTPUT device from " + currentOutputDevice + " to " + selectedDevice);
-            Menu.setIsOptionChecked("Use " + currentOutputDevice + " for Output", false);
-            if (AudioDevice.setOutputDevice(selectedDevice)) {
-                Settings.setValue(OUTPUT_DEVICE_SETTING, selectedDevice);
-                Menu.setIsOptionChecked(audioDeviceMenuString, true);
-            } else {
-                debug("Error setting audio output device!")
-                Menu.setIsOptionChecked(audioDeviceMenuString, false);
-            }
-        } else {
-            debug("Selected output device is the same as the current output device!")
-            Settings.setValue(OUTPUT_DEVICE_SETTING, selectedDevice);
-            Menu.setIsOptionChecked(audioDeviceMenuString, true);
-            AudioDevice.setOutputDevice(selectedDevice); // Still try to force-set the device (in case the user's trying to forcefully debug an issue)
-        }
-    }
-}
-
 function restoreAudio() {
     if (switchedAudioInputToHMD) {
         debug("Switching back from HMD preferred audio input to: " + previousSelectedInputAudioDevice);
-        switchAudioDevice("Use " +  previousSelectedInputAudioDevice + " for Input");
+        AudioDevice.setInputDeviceAsync(previousSelectedInputAudioDevice)
         switchedAudioInputToHMD = false;
     }
     if (switchedAudioOutputToHMD) {
         debug("Switching back from HMD preferred audio output to: " + previousSelectedOutputAudioDevice);
-        switchAudioDevice("Use " + previousSelectedOutputAudioDevice + " for Output");
+        AudioDevice.setOutputDeviceAsync(previousSelectedOutputAudioDevice)
         switchedAudioOutputToHMD = false;
     }
 }
@@ -240,7 +156,7 @@ function checkHMDAudio() {
                 debug("previousSelectedInputAudioDevice: " + previousSelectedInputAudioDevice);
                 if (hmdPreferredAudioInput != previousSelectedInputAudioDevice) {
                     switchedAudioInputToHMD = true;
-                    switchAudioDevice("Use " + hmdPreferredAudioInput + " for Input");
+                    AudioDevice.setInputDeviceAsync(hmdPreferredAudioInput)
                 }
             }
             if (hmdPreferredAudioOutput !== "") {
@@ -249,7 +165,7 @@ function checkHMDAudio() {
                 debug("previousSelectedOutputAudioDevice: " + previousSelectedOutputAudioDevice);
                 if (hmdPreferredAudioOutput != previousSelectedOutputAudioDevice) {
                     switchedAudioOutputToHMD = true;
-                    switchAudioDevice("Use " + hmdPreferredAudioOutput + " for Output");
+                    AudioDevice.setOutputDeviceAsync(hmdPreferredAudioOutput)
                 }
             }
         } else {
@@ -277,10 +193,9 @@ Script.setTimeout(function () {
     Menu.menuItemEvent.connect(onMenuEvent);
     debug("Setting up Audio I/O menu for the first time...");
     setupAudioMenus();
-    checkDeviceMismatch();
     debug("Checking HMD audio status...")
     checkHMDAudio();
-}, 3000);
+}, 300);
 
 debug("Connecting scriptEnding()");
 Script.scriptEnding.connect(function () {