expo-juce 0.3.0 → 0.3.2

package/ios/juce_modules/juce_audio_devices/audio_io/juce_AudioDeviceManager.cpp

@@ -0,0 +1,1957 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE framework.
+   Copyright (c) Raw Material Software Limited
+
+   JUCE is an open source framework subject to commercial or open source
+   licensing.
+
+   By downloading, installing, or using the JUCE framework, or combining the
+   JUCE framework with any other source code, object code, content or any other
+   copyrightable work, you agree to the terms of the JUCE End User Licence
+   Agreement, and all incorporated terms including the JUCE Privacy Policy and
+   the JUCE Website Terms of Service, as applicable, which will bind you. If you
+   do not agree to the terms of these agreements, we will not license the JUCE
+   framework to you, and you must discontinue the installation or download
+   process and cease use of the JUCE framework.
+
+   JUCE End User Licence Agreement: https://juce.com/legal/juce-8-licence/
+   JUCE Privacy Policy: https://juce.com/juce-privacy-policy
+   JUCE Website Terms of Service: https://juce.com/juce-website-terms-of-service/
+
+   Or:
+
+   You may also use this code under the terms of the AGPLv3:
+   https://www.gnu.org/licenses/agpl-3.0.en.html
+
+   THE JUCE FRAMEWORK IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL
+   WARRANTIES, WHETHER EXPRESSED OR IMPLIED, INCLUDING WARRANTY OF
+   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, ARE DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+template <typename Setup>
+static auto getSetupInfo (Setup& s, bool isInput)
+{
+    struct SetupInfo
+    {
+        // double brackets so that we get the expression type, i.e. a (possibly const) reference
+        decltype ((s.inputDeviceName)) name;
+        decltype ((s.inputChannels)) channels;
+        decltype ((s.useDefaultInputChannels)) useDefault;
+    };
+
+    return isInput ? SetupInfo { s.inputDeviceName,  s.inputChannels,  s.useDefaultInputChannels }
+                   : SetupInfo { s.outputDeviceName, s.outputChannels, s.useDefaultOutputChannels };
+}
+
+static auto tie (const AudioDeviceManager::AudioDeviceSetup& s)
+{
+    return std::tie (s.outputDeviceName,
+                     s.inputDeviceName,
+                     s.sampleRate,
+                     s.bufferSize,
+                     s.inputChannels,
+                     s.useDefaultInputChannels,
+                     s.outputChannels,
+                     s.useDefaultOutputChannels);
+}
+
+bool AudioDeviceManager::AudioDeviceSetup::operator== (const AudioDeviceManager::AudioDeviceSetup& other) const
+{
+    return tie (*this) == tie (other);
+}
+
+bool AudioDeviceManager::AudioDeviceSetup::operator!= (const AudioDeviceManager::AudioDeviceSetup& other) const
+{
+    return tie (*this) != tie (other);
+}
+
+//==============================================================================
+class AudioDeviceManager::CallbackHandler final : public AudioIODeviceCallback,
+                                                  public MidiInputCallback,
+                                                  public AudioIODeviceType::Listener
+{
+public:
+    CallbackHandler (AudioDeviceManager& adm) noexcept  : owner (adm) {}
+
+private:
+    void audioDeviceIOCallbackWithContext (const float* const* ins,
+                                           int numIns,
+                                           float* const* outs,
+                                           int numOuts,
+                                           int numSamples,
+                                           const AudioIODeviceCallbackContext& context) override
+    {
+        owner.audioDeviceIOCallbackInt (ins, numIns, outs, numOuts, numSamples, context);
+    }
+
+    void audioDeviceAboutToStart (AudioIODevice* device) override
+    {
+        owner.audioDeviceAboutToStartInt (device);
+    }
+
+    void audioDeviceStopped() override
+    {
+        owner.audioDeviceStoppedInt();
+    }
+
+    void audioDeviceError (const String& message) override
+    {
+        owner.audioDeviceErrorInt (message);
+    }
+
+    void handleIncomingMidiMessage (MidiInput* source, const MidiMessage& message) override
+    {
+        owner.handleIncomingMidiMessageInt (source, message);
+    }
+
+    void audioDeviceListChanged() override
+    {
+        owner.audioDeviceListChanged();
+    }
+
+    AudioDeviceManager& owner;
+
+    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (CallbackHandler)
+};
+
+//==============================================================================
+AudioDeviceManager::AudioDeviceManager()
+{
+    callbackHandler.reset (new CallbackHandler (*this));
+}
+
+AudioDeviceManager::~AudioDeviceManager()
+{
+    currentAudioDevice.reset();
+    defaultMidiOutput.reset();
+}
+
+//==============================================================================
+void AudioDeviceManager::createDeviceTypesIfNeeded()
+{
+    if (availableDeviceTypes.size() == 0)
+    {
+        OwnedArray<AudioIODeviceType> types;
+        createAudioDeviceTypes (types);
+
+        for (auto* t : types)
+            addAudioDeviceType (std::unique_ptr<AudioIODeviceType> (t));
+
+        types.clear (false);
+
+        for (auto* type : availableDeviceTypes)
+            type->scanForDevices();
+
+        pickCurrentDeviceTypeWithDevices();
+    }
+}
+
+void AudioDeviceManager::pickCurrentDeviceTypeWithDevices()
+{
+    const auto deviceTypeHasDevices = [] (const AudioIODeviceType* ptr)
+    {
+        return ! ptr->getDeviceNames (true) .isEmpty()
+            || ! ptr->getDeviceNames (false).isEmpty();
+    };
+
+    if (auto* type = findType (currentDeviceType))
+        if (deviceTypeHasDevices (type))
+            return;
+
+    const auto iter = std::find_if (availableDeviceTypes.begin(),
+                                    availableDeviceTypes.end(),
+                                    deviceTypeHasDevices);
+
+    if (iter != availableDeviceTypes.end())
+        currentDeviceType = (*iter)->getTypeName();
+}
+
+const OwnedArray<AudioIODeviceType>& AudioDeviceManager::getAvailableDeviceTypes()
+{
+    scanDevicesIfNeeded();
+    return availableDeviceTypes;
+}
+
+void AudioDeviceManager::updateCurrentSetup()
+{
+    if (currentAudioDevice != nullptr)
+    {
+        currentSetup.sampleRate     = currentAudioDevice->getCurrentSampleRate();
+        currentSetup.bufferSize     = currentAudioDevice->getCurrentBufferSizeSamples();
+        currentSetup.inputChannels  = currentAudioDevice->getActiveInputChannels();
+        currentSetup.outputChannels = currentAudioDevice->getActiveOutputChannels();
+    }
+}
+
+void AudioDeviceManager::audioDeviceListChanged()
+{
+    if (currentAudioDevice != nullptr)
+    {
+        auto currentDeviceStillAvailable = [&]
+        {
+            auto currentTypeName = currentAudioDevice->getTypeName();
+            auto currentDeviceName = currentAudioDevice->getName();
+
+            for (auto* deviceType : availableDeviceTypes)
+            {
+                if (currentTypeName == deviceType->getTypeName())
+                {
+                    for (auto& deviceName : deviceType->getDeviceNames (true))
+                        if (currentDeviceName == deviceName)
+                            return true;
+
+                    for (auto& deviceName : deviceType->getDeviceNames (false))
+                        if (currentDeviceName == deviceName)
+                            return true;
+                }
+            }
+
+            return false;
+        }();
+
+        if (! currentDeviceStillAvailable)
+        {
+            closeAudioDevice();
+
+            if (auto e = createStateXml())
+                initialiseFromXML (*e, true, preferredDeviceName, &currentSetup);
+            else
+                initialiseDefault (preferredDeviceName, &currentSetup);
+        }
+
+        updateCurrentSetup();
+    }
+
+    sendChangeMessage();
+}
+
+void AudioDeviceManager::midiDeviceListChanged()
+{
+    openLastRequestedMidiDevices (midiDeviceInfosFromXml, defaultMidiOutputDeviceInfo);
+    sendChangeMessage();
+}
+
+//==============================================================================
+static void addIfNotNull (OwnedArray<AudioIODeviceType>& list, AudioIODeviceType* const device)
+{
+    if (device != nullptr)
+        list.add (device);
+}
+
+void AudioDeviceManager::createAudioDeviceTypes (OwnedArray<AudioIODeviceType>& list)
+{
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_WASAPI (WASAPIDeviceMode::shared));
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_WASAPI (WASAPIDeviceMode::exclusive));
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_WASAPI (WASAPIDeviceMode::sharedLowLatency));
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_DirectSound());
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_ASIO());
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_CoreAudio());
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_iOSAudio());
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_Bela());
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_ALSA());
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_JACK());
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_Oboe());
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_OpenSLES());
+    addIfNotNull (list, AudioIODeviceType::createAudioIODeviceType_Android());
+}
+
+void AudioDeviceManager::addAudioDeviceType (std::unique_ptr<AudioIODeviceType> newDeviceType)
+{
+    if (newDeviceType != nullptr)
+    {
+        jassert (lastDeviceTypeConfigs.size() == availableDeviceTypes.size());
+
+        availableDeviceTypes.add (newDeviceType.release());
+        lastDeviceTypeConfigs.add (new AudioDeviceSetup());
+
+        availableDeviceTypes.getLast()->addListener (callbackHandler.get());
+    }
+}
+
+void AudioDeviceManager::removeAudioDeviceType (AudioIODeviceType* deviceTypeToRemove)
+{
+    if (deviceTypeToRemove != nullptr)
+    {
+        jassert (lastDeviceTypeConfigs.size() == availableDeviceTypes.size());
+
+        auto index = availableDeviceTypes.indexOf (deviceTypeToRemove);
+
+        if (auto removed = std::unique_ptr<AudioIODeviceType> (availableDeviceTypes.removeAndReturn (index)))
+        {
+            removed->removeListener (callbackHandler.get());
+            lastDeviceTypeConfigs.remove (index, true);
+        }
+    }
+}
+
+static bool deviceListContains (AudioIODeviceType* type, bool isInput, const String& name)
+{
+    for (auto& deviceName : type->getDeviceNames (isInput))
+        if (deviceName.trim().equalsIgnoreCase (name.trim()))
+            return true;
+
+    return false;
+}
+
+//==============================================================================
+String AudioDeviceManager::initialise (const int numInputChannelsNeeded,
+                                       const int numOutputChannelsNeeded,
+                                       const XmlElement* const xml,
+                                       const bool selectDefaultDeviceOnFailure,
+                                       const String& preferredDefaultDeviceName,
+                                       const AudioDeviceSetup* preferredSetupOptions)
+{
+    scanDevicesIfNeeded();
+    pickCurrentDeviceTypeWithDevices();
+
+    numInputChansNeeded = numInputChannelsNeeded;
+    numOutputChansNeeded = numOutputChannelsNeeded;
+    preferredDeviceName = preferredDefaultDeviceName;
+
+    if (xml != nullptr && xml->hasTagName ("DEVICESETUP"))
+        return initialiseFromXML (*xml, selectDefaultDeviceOnFailure,
+                                  preferredDeviceName, preferredSetupOptions);
+
+    return initialiseDefault (preferredDeviceName, preferredSetupOptions);
+}
+
+String AudioDeviceManager::initialiseDefault (const String& preferredDefaultDeviceName,
+                                              const AudioDeviceSetup* preferredSetupOptions)
+{
+    AudioDeviceSetup setup;
+
+    if (preferredSetupOptions != nullptr)
+    {
+        setup = *preferredSetupOptions;
+    }
+    else if (preferredDefaultDeviceName.isNotEmpty())
+    {
+        const auto nameMatches = [&preferredDefaultDeviceName] (const String& name)
+        {
+            return name.matchesWildcard (preferredDefaultDeviceName, true);
+        };
+
+        struct WildcardMatch
+        {
+            String value;
+            bool successful;
+        };
+
+        const auto getWildcardMatch = [&nameMatches] (const StringArray& names)
+        {
+            const auto iter = std::find_if (names.begin(), names.end(), nameMatches);
+            return WildcardMatch { iter != names.end() ? *iter : String(), iter != names.end() };
+        };
+
+        struct WildcardMatches
+        {
+            WildcardMatch input, output;
+        };
+
+        const auto getMatchesForType = [&getWildcardMatch] (const AudioIODeviceType* type)
+        {
+            return WildcardMatches { getWildcardMatch (type->getDeviceNames (true)),
+                                     getWildcardMatch (type->getDeviceNames (false)) };
+        };
+
+        struct SearchResult
+        {
+            String type, input, output;
+        };
+
+        const auto result = [&]
+        {
+            // First, look for a device type with an input and output which matches the preferred name
+            for (auto* type : availableDeviceTypes)
+            {
+                const auto matches = getMatchesForType (type);
+
+                if (matches.input.successful && matches.output.successful)
+                    return SearchResult { type->getTypeName(), matches.input.value, matches.output.value };
+            }
+
+            // No device type has matching ins and outs, so fall back to a device where either the
+            // input or output match
+            for (auto* type : availableDeviceTypes)
+            {
+                const auto matches = getMatchesForType (type);
+
+                if (matches.input.successful || matches.output.successful)
+                    return SearchResult { type->getTypeName(), matches.input.value, matches.output.value };
+            }
+
+            // No devices match the query, so just use the default devices from the current type
+            return SearchResult { currentDeviceType, {}, {} };
+        }();
+
+        currentDeviceType = result.type;
+        setup.inputDeviceName = result.input;
+        setup.outputDeviceName = result.output;
+    }
+
+    insertDefaultDeviceNames (setup);
+    return setAudioDeviceSetup (setup, false);
+}
+
+String AudioDeviceManager::initialiseFromXML (const XmlElement& xml,
+                                              bool selectDefaultDeviceOnFailure,
+                                              const String& preferredDefaultDeviceName,
+                                              const AudioDeviceSetup* preferredSetupOptions)
+{
+    lastExplicitSettings.reset (new XmlElement (xml));
+
+    String error;
+    AudioDeviceSetup setup;
+
+    if (preferredSetupOptions != nullptr)
+        setup = *preferredSetupOptions;
+
+    if (xml.getStringAttribute ("audioDeviceName").isNotEmpty())
+    {
+        setup.inputDeviceName = setup.outputDeviceName
+            = xml.getStringAttribute ("audioDeviceName");
+    }
+    else
+    {
+        setup.inputDeviceName  = xml.getStringAttribute ("audioInputDeviceName");
+        setup.outputDeviceName = xml.getStringAttribute ("audioOutputDeviceName");
+    }
+
+    currentDeviceType = xml.getStringAttribute ("deviceType");
+
+    if (findType (currentDeviceType) == nullptr)
+    {
+        if (auto* type = findType (setup.inputDeviceName, setup.outputDeviceName))
+            currentDeviceType = type->getTypeName();
+        else if (auto* firstType = availableDeviceTypes.getFirst())
+            currentDeviceType = firstType->getTypeName();
+    }
+
+    setup.bufferSize = xml.getIntAttribute ("audioDeviceBufferSize", setup.bufferSize);
+    setup.sampleRate = xml.getDoubleAttribute ("audioDeviceRate", setup.sampleRate);
+
+    setup.inputChannels .parseString (xml.getStringAttribute ("audioDeviceInChans",  "11"), 2);
+    setup.outputChannels.parseString (xml.getStringAttribute ("audioDeviceOutChans", "11"), 2);
+
+    setup.useDefaultInputChannels  = ! xml.hasAttribute ("audioDeviceInChans");
+    setup.useDefaultOutputChannels = ! xml.hasAttribute ("audioDeviceOutChans");
+
+    error = setAudioDeviceSetup (setup, true);
+
+    if (error.isNotEmpty() && selectDefaultDeviceOnFailure)
+        error = initialise (numInputChansNeeded, numOutputChansNeeded, nullptr, false, preferredDefaultDeviceName);
+
+    enabledMidiInputs.clear();
+
+    const auto midiInputs = [&]
+    {
+        Array<MidiDeviceInfo> result;
+
+        for (auto* c : xml.getChildWithTagNameIterator ("MIDIINPUT"))
+            result.add ({ c->getStringAttribute ("name"), c->getStringAttribute ("identifier") });
+
+        return result;
+    }();
+
+    const MidiDeviceInfo defaultOutputDeviceInfo (xml.getStringAttribute ("defaultMidiOutput"),
+                                                  xml.getStringAttribute ("defaultMidiOutputDevice"));
+
+    openLastRequestedMidiDevices (midiInputs, defaultOutputDeviceInfo);
+
+    return error;
+}
+
+void AudioDeviceManager::openLastRequestedMidiDevices (const Array<MidiDeviceInfo>& desiredInputs, const MidiDeviceInfo& defaultOutput)
+{
+    const auto openDeviceIfAvailable = [&] (const Array<MidiDeviceInfo>& devices,
+                                            const MidiDeviceInfo& deviceToOpen,
+                                            auto&& doOpen)
+    {
+        const auto iterWithMatchingIdentifier = std::find_if (devices.begin(), devices.end(), [&] (const auto& x)
+        {
+            return x.identifier == deviceToOpen.identifier;
+        });
+
+        if (iterWithMatchingIdentifier != devices.end())
+        {
+            doOpen (deviceToOpen.identifier);
+            return;
+        }
+
+        const auto iterWithMatchingName = std::find_if (devices.begin(), devices.end(), [&] (const auto& x)
+        {
+            return x.name == deviceToOpen.name;
+        });
+
+        if (iterWithMatchingName != devices.end())
+            doOpen (iterWithMatchingName->identifier);
+    };
+
+    midiDeviceInfosFromXml = desiredInputs;
+
+    const auto inputs = MidiInput::getAvailableDevices();
+
+    for (const auto& info : midiDeviceInfosFromXml)
+        openDeviceIfAvailable (inputs, info, [&] (const auto identifier) { setMidiInputDeviceEnabled (identifier, true); });
+
+    const auto outputs = MidiOutput::getAvailableDevices();
+
+    openDeviceIfAvailable (outputs, defaultOutput, [&] (const auto identifier) { setDefaultMidiOutputDevice (identifier); });
+}
+
+String AudioDeviceManager::initialiseWithDefaultDevices (int numInputChannelsNeeded,
+                                                         int numOutputChannelsNeeded)
+{
+    lastExplicitSettings.reset();
+
+    return initialise (numInputChannelsNeeded, numOutputChannelsNeeded,
+                       nullptr, false, {}, nullptr);
+}
+
+void AudioDeviceManager::insertDefaultDeviceNames (AudioDeviceSetup& setup) const
+{
+    enum class Direction { out, in };
+
+    if (auto* type = getCurrentDeviceTypeObject())
+    {
+        // We avoid selecting a device pair that doesn't share a matching sample rate, if possible.
+        // If not, other parts of the AudioDeviceManager and AudioIODevice classes should generate
+        // an appropriate error message when opening or starting these devices.
+        const auto getDevicesToTestForMatchingSampleRate = [&setup, type, this] (Direction dir)
+        {
+            const auto isInput = dir == Direction::in;
+            const auto info = getSetupInfo (setup, isInput);
+
+            if (! info.name.isEmpty())
+                return StringArray { info.name };
+
+            const auto numChannelsNeeded = isInput ? numInputChansNeeded : numOutputChansNeeded;
+            auto deviceNames = numChannelsNeeded > 0 ? type->getDeviceNames (isInput) : StringArray {};
+            deviceNames.move (type->getDefaultDeviceIndex (isInput), 0);
+
+            return deviceNames;
+        };
+
+        std::map<std::pair<Direction, String>, Array<double>> sampleRatesCache;
+
+        const auto getSupportedSampleRates = [&sampleRatesCache, type] (Direction dir, const String& deviceName)
+        {
+            const auto key = std::make_pair (dir, deviceName);
+
+            auto& entry = [&]() -> auto&
+            {
+                auto it = sampleRatesCache.find (key);
+
+                if (it != sampleRatesCache.end())
+                    return it->second;
+
+                auto& elem = sampleRatesCache[key];
+                auto tempDevice = rawToUniquePtr (type->createDevice ((dir == Direction::in) ? "" : deviceName,
+                                                                      (dir == Direction::in) ? deviceName : ""));
+                if (tempDevice != nullptr)
+                    elem = tempDevice->getAvailableSampleRates();
+
+                return elem;
+            }();
+
+            return entry;
+        };
+
+        const auto validate = [&getSupportedSampleRates] (const String& outputDeviceName, const String& inputDeviceName)
+        {
+            jassert (! outputDeviceName.isEmpty() && ! inputDeviceName.isEmpty());
+
+            const auto outputSampleRates = getSupportedSampleRates (Direction::out, outputDeviceName);
+            const auto inputSampleRates  = getSupportedSampleRates (Direction::in,  inputDeviceName);
+
+            return std::any_of (inputSampleRates.begin(),
+                                inputSampleRates.end(),
+                                [&] (auto inputSampleRate) { return outputSampleRates.contains (inputSampleRate); });
+        };
+
+        auto outputsToTest = getDevicesToTestForMatchingSampleRate (Direction::out);
+        auto inputsToTest  = getDevicesToTestForMatchingSampleRate (Direction::in);
+
+        // We set default device names, so in case no in-out pair passes the validation, we still
+        // produce the same result as before
+        if (setup.outputDeviceName.isEmpty() && ! outputsToTest.isEmpty())
+            setup.outputDeviceName = outputsToTest[0];
+
+        if (setup.inputDeviceName.isEmpty() && ! inputsToTest.isEmpty())
+            setup.inputDeviceName = inputsToTest[0];
+
+        // We check all possible in-out pairs until the first validation pass. If no pair passes we
+        // leave the setup unchanged.
+        for (const auto& out : outputsToTest)
+        {
+            for (const auto& in : inputsToTest)
+            {
+                if (validate (out, in))
+                {
+                    setup.outputDeviceName = out;
+                    setup.inputDeviceName  = in;
+
+                    return;
+                }
+            }
+        }
+    }
+}
+
+std::unique_ptr<XmlElement> AudioDeviceManager::createStateXml() const
+{
+    if (lastExplicitSettings != nullptr)
+        return std::make_unique<XmlElement> (*lastExplicitSettings);
+
+    return {};
+}
+
+//==============================================================================
+void AudioDeviceManager::scanDevicesIfNeeded()
+{
+    if (listNeedsScanning)
+    {
+        listNeedsScanning = false;
+
+        createDeviceTypesIfNeeded();
+
+        for (auto* type : availableDeviceTypes)
+            type->scanForDevices();
+    }
+}
+
+AudioIODeviceType* AudioDeviceManager::findType (const String& typeName)
+{
+    scanDevicesIfNeeded();
+
+    for (auto* type : availableDeviceTypes)
+        if (type->getTypeName() == typeName)
+            return type;
+
+    return {};
+}
+
+AudioIODeviceType* AudioDeviceManager::findType (const String& inputName, const String& outputName)
+{
+    scanDevicesIfNeeded();
+
+    for (auto* type : availableDeviceTypes)
+        if ((inputName.isNotEmpty() && deviceListContains (type, true, inputName))
+             || (outputName.isNotEmpty() && deviceListContains (type, false, outputName)))
+            return type;
+
+    return {};
+}
+
+AudioDeviceManager::AudioDeviceSetup AudioDeviceManager::getAudioDeviceSetup() const
+{
+    return currentSetup;
+}
+
+void AudioDeviceManager::getAudioDeviceSetup (AudioDeviceSetup& setup) const
+{
+    setup = currentSetup;
+}
+
+void AudioDeviceManager::deleteCurrentDevice()
+{
+    currentAudioDevice.reset();
+    currentSetup.inputDeviceName.clear();
+    currentSetup.outputDeviceName.clear();
+}
+
+void AudioDeviceManager::setCurrentAudioDeviceType (const String& type, bool treatAsChosenDevice)
+{
+    for (int i = 0; i < availableDeviceTypes.size(); ++i)
+    {
+        if (availableDeviceTypes.getUnchecked (i)->getTypeName() == type
+             && currentDeviceType != type)
+        {
+            if (currentAudioDevice != nullptr)
+            {
+                closeAudioDevice();
+                Thread::sleep (1500); // allow a moment for OS devices to sort themselves out, to help
+                                      // avoid things like DirectSound/ASIO clashes
+            }
+
+            currentDeviceType = type;
+
+            AudioDeviceSetup s (*lastDeviceTypeConfigs.getUnchecked (i));
+            insertDefaultDeviceNames (s);
+
+            setAudioDeviceSetup (s, treatAsChosenDevice);
+
+            sendChangeMessage();
+            break;
+        }
+    }
+}
+
+AudioWorkgroup AudioDeviceManager::getDeviceAudioWorkgroup() const
+{
+    return currentAudioDevice != nullptr ? currentAudioDevice->getWorkgroup() : AudioWorkgroup{};
+}
+
+AudioIODeviceType* AudioDeviceManager::getCurrentDeviceTypeObject() const
+{
+    for (auto* type : availableDeviceTypes)
+        if (type->getTypeName() == currentDeviceType)
+            return type;
+
+    return availableDeviceTypes.getFirst();
+}
+
+static void updateSetupChannels (AudioDeviceManager::AudioDeviceSetup& setup, int defaultNumIns, int defaultNumOuts)
+{
+    auto updateChannels = [] (const String& deviceName, BigInteger& channels, int defaultNumChannels)
+    {
+        if (deviceName.isEmpty())
+        {
+            channels.clear();
+        }
+        else if (defaultNumChannels != -1)
+        {
+            channels.clear();
+            channels.setRange (0, defaultNumChannels, true);
+        }
+    };
+
+    updateChannels (setup.inputDeviceName,  setup.inputChannels,  setup.useDefaultInputChannels  ? defaultNumIns  : -1);
+    updateChannels (setup.outputDeviceName, setup.outputChannels, setup.useDefaultOutputChannels ? defaultNumOuts : -1);
+}
+
+String AudioDeviceManager::setAudioDeviceSetup (const AudioDeviceSetup& newSetup,
+                                                bool treatAsChosenDevice)
+{
+    jassert (&newSetup != &currentSetup);    // this will have no effect
+
+    if (newSetup != currentSetup)
+        sendChangeMessage();
+    else if (currentAudioDevice != nullptr)
+        return {};
+
+    stopDevice();
+
+    if (getCurrentDeviceTypeObject() == nullptr
+        || (newSetup.inputDeviceName.isEmpty() && newSetup.outputDeviceName.isEmpty()))
+    {
+        deleteCurrentDevice();
+
+        if (treatAsChosenDevice)
+            updateXml();
+
+        return {};
+    }
+
+    String error;
+
+    const auto needsNewDevice = currentSetup.inputDeviceName  != newSetup.inputDeviceName
+                             || currentSetup.outputDeviceName != newSetup.outputDeviceName
+                             || currentAudioDevice == nullptr;
+
+    if (needsNewDevice)
+    {
+        deleteCurrentDevice();
+        scanDevicesIfNeeded();
+
+        auto* type = getCurrentDeviceTypeObject();
+
+        for (const auto isInput : { false, true })
+        {
+            const auto name = getSetupInfo (newSetup, isInput).name;
+
+            if (name.isNotEmpty() && ! deviceListContains (type, isInput, name))
+                return "No such device: " + name;
+        }
+
+        currentAudioDevice.reset (type->createDevice (newSetup.outputDeviceName, newSetup.inputDeviceName));
+
+        if (currentAudioDevice == nullptr)
+            error = "Can't open the audio device!\n\n"
+                    "This may be because another application is currently using the same device - "
+                    "if so, you should close any other applications and try again!";
+        else
+            error = currentAudioDevice->getLastError();
+
+        if (error.isNotEmpty())
+        {
+            deleteCurrentDevice();
+            return error;
+        }
+    }
+
+    currentSetup = newSetup;
+
+    if (! currentSetup.useDefaultInputChannels)    numInputChansNeeded  = currentSetup.inputChannels.countNumberOfSetBits();
+    if (! currentSetup.useDefaultOutputChannels)   numOutputChansNeeded = currentSetup.outputChannels.countNumberOfSetBits();
+
+    updateSetupChannels (currentSetup, numInputChansNeeded, numOutputChansNeeded);
+
+    if (currentSetup.inputChannels.isZero() && currentSetup.outputChannels.isZero())
+    {
+        if (treatAsChosenDevice)
+            updateXml();
+
+        return {};
+    }
+
+    currentSetup.sampleRate = chooseBestSampleRate (currentSetup.sampleRate);
+    currentSetup.bufferSize = chooseBestBufferSize (currentSetup.bufferSize);
+
+    error = currentAudioDevice->open (currentSetup.inputChannels,
+                                      currentSetup.outputChannels,
+                                      currentSetup.sampleRate,
+                                      currentSetup.bufferSize);
+
+    if (error.isEmpty())
+    {
+        currentDeviceType = currentAudioDevice->getTypeName();
+
+        currentAudioDevice->start (callbackHandler.get());
+
+        error = currentAudioDevice->getLastError();
+    }
+
+    if (error.isEmpty())
+    {
+        updateCurrentSetup();
+
+        for (int i = 0; i < availableDeviceTypes.size(); ++i)
+            if (availableDeviceTypes.getUnchecked (i)->getTypeName() == currentDeviceType)
+                *(lastDeviceTypeConfigs.getUnchecked (i)) = currentSetup;
+
+        if (treatAsChosenDevice)
+            updateXml();
+    }
+    else
+    {
+        deleteCurrentDevice();
+    }
+
+    return error;
+}
+
+double AudioDeviceManager::chooseBestSampleRate (double rate) const
+{
+    jassert (currentAudioDevice != nullptr);
+
+    auto rates = currentAudioDevice->getAvailableSampleRates();
+
+    if (rate > 0 && rates.contains (rate))
+        return rate;
+
+    rate = currentAudioDevice->getCurrentSampleRate();
+
+    if (rate > 0 && rates.contains (rate))
+        return rate;
+
+    double lowestAbove44 = 0.0;
+
+    for (int i = rates.size(); --i >= 0;)
+    {
+        auto sr = rates[i];
+
+        if (sr >= 44100.0 && (lowestAbove44 < 1.0 || sr < lowestAbove44))
+            lowestAbove44 = sr;
+    }
+
+    if (lowestAbove44 > 0.0)
+        return lowestAbove44;
+
+    return rates[0];
+}
+
+int AudioDeviceManager::chooseBestBufferSize (int bufferSize) const
+{
+    jassert (currentAudioDevice != nullptr);
+
+    if (bufferSize > 0 && currentAudioDevice->getAvailableBufferSizes().contains (bufferSize))
+        return bufferSize;
+
+    return currentAudioDevice->getDefaultBufferSize();
+}
+
+void AudioDeviceManager::stopDevice()
+{
+    if (currentAudioDevice != nullptr)
+        currentAudioDevice->stop();
+
+    testSound.reset();
+}
+
+void AudioDeviceManager::closeAudioDevice()
+{
+    stopDevice();
+    currentAudioDevice.reset();
+    loadMeasurer.reset();
+}
+
+void AudioDeviceManager::restartLastAudioDevice()
+{
+    if (currentAudioDevice == nullptr)
+    {
+        if (currentSetup.inputDeviceName.isEmpty()
+              && currentSetup.outputDeviceName.isEmpty())
+        {
+            // This method will only reload the last device that was running
+            // before closeAudioDevice() was called - you need to actually open
+            // one first, with setAudioDeviceSetup().
+            jassertfalse;
+            return;
+        }
+
+        AudioDeviceSetup s (currentSetup);
+        setAudioDeviceSetup (s, false);
+    }
+}
+
+void AudioDeviceManager::updateXml()
+{
+    lastExplicitSettings.reset (new XmlElement ("DEVICESETUP"));
+
+    lastExplicitSettings->setAttribute ("deviceType", currentDeviceType);
+    lastExplicitSettings->setAttribute ("audioOutputDeviceName", currentSetup.outputDeviceName);
+    lastExplicitSettings->setAttribute ("audioInputDeviceName", currentSetup.inputDeviceName);
+
+    if (currentAudioDevice != nullptr)
+    {
+        lastExplicitSettings->setAttribute ("audioDeviceRate", currentAudioDevice->getCurrentSampleRate());
+
+        if (currentAudioDevice->getDefaultBufferSize() != currentAudioDevice->getCurrentBufferSizeSamples())
+            lastExplicitSettings->setAttribute ("audioDeviceBufferSize", currentAudioDevice->getCurrentBufferSizeSamples());
+
+        if (! currentSetup.useDefaultInputChannels)
+            lastExplicitSettings->setAttribute ("audioDeviceInChans", currentSetup.inputChannels.toString (2));
+
+        if (! currentSetup.useDefaultOutputChannels)
+            lastExplicitSettings->setAttribute ("audioDeviceOutChans", currentSetup.outputChannels.toString (2));
+    }
+
+    for (auto& input : enabledMidiInputs)
+    {
+        auto* child = lastExplicitSettings->createNewChildElement ("MIDIINPUT");
+
+        child->setAttribute ("name",       input->getName());
+        child->setAttribute ("identifier", input->getIdentifier());
+    }
+
+    if (midiDeviceInfosFromXml.size() > 0)
+    {
+        // Add any midi devices that have been enabled before, but which aren't currently
+        // open because the device has been disconnected.
+        auto availableMidiDevices = MidiInput::getAvailableDevices();
+
+        for (auto& d : midiDeviceInfosFromXml)
+        {
+            if (! availableMidiDevices.contains (d))
+            {
+                auto* child = lastExplicitSettings->createNewChildElement ("MIDIINPUT");
+
+                child->setAttribute ("name",       d.name);
+                child->setAttribute ("identifier", d.identifier);
+            }
+        }
+    }
+
+    if (defaultMidiOutputDeviceInfo != MidiDeviceInfo())
+    {
+        lastExplicitSettings->setAttribute ("defaultMidiOutput",       defaultMidiOutputDeviceInfo.name);
+        lastExplicitSettings->setAttribute ("defaultMidiOutputDevice", defaultMidiOutputDeviceInfo.identifier);
+    }
+}
+
+//==============================================================================
+void AudioDeviceManager::addAudioCallback (AudioIODeviceCallback* newCallback)
+{
+    {
+        const ScopedLock sl (audioCallbackLock);
+
+        if (callbacks.contains (newCallback))
+            return;
+    }
+
+    if (currentAudioDevice != nullptr && newCallback != nullptr)
+        newCallback->audioDeviceAboutToStart (currentAudioDevice.get());
+
+    const ScopedLock sl (audioCallbackLock);
+    callbacks.add (newCallback);
+}
+
+void AudioDeviceManager::removeAudioCallback (AudioIODeviceCallback* callbackToRemove)
+{
+    if (callbackToRemove != nullptr)
+    {
+        bool needsDeinitialising = currentAudioDevice != nullptr;
+
+        {
+            const ScopedLock sl (audioCallbackLock);
+
+            needsDeinitialising = needsDeinitialising && callbacks.contains (callbackToRemove);
+            callbacks.removeFirstMatchingValue (callbackToRemove);
+        }
+
+        if (needsDeinitialising)
+            callbackToRemove->audioDeviceStopped();
+    }
+}
+
+void AudioDeviceManager::audioDeviceIOCallbackInt (const float* const* inputChannelData,
+                                                   int numInputChannels,
+                                                   float* const* outputChannelData,
+                                                   int numOutputChannels,
+                                                   int numSamples,
+                                                   const AudioIODeviceCallbackContext& context)
+{
+    const ScopedLock sl (audioCallbackLock);
+
+    inputLevelGetter->updateLevel (inputChannelData, numInputChannels, numSamples);
+
+    if (callbacks.size() > 0)
+    {
+        AudioProcessLoadMeasurer::ScopedTimer timer (loadMeasurer, numSamples);
+
+        tempBuffer.setSize (jmax (1, numOutputChannels), jmax (1, numSamples), false, false, true);
+
+        callbacks.getUnchecked (0)->audioDeviceIOCallbackWithContext (inputChannelData,
+                                                                      numInputChannels,
+                                                                      outputChannelData,
+                                                                      numOutputChannels,
+                                                                      numSamples,
+                                                                      context);
+
+        auto* const* tempChans = tempBuffer.getArrayOfWritePointers();
+
+        for (int i = callbacks.size(); --i > 0;)
+        {
+            callbacks.getUnchecked (i)->audioDeviceIOCallbackWithContext (inputChannelData,
+                                                                          numInputChannels,
+                                                                          tempChans,
+                                                                          numOutputChannels,
+                                                                          numSamples,
+                                                                          context);
+
+            for (int chan = 0; chan < numOutputChannels; ++chan)
+            {
+                if (auto* src = tempChans [chan])
+                    if (auto* dst = outputChannelData [chan])
+                        for (int j = 0; j < numSamples; ++j)
+                            dst[j] += src[j];
+            }
+        }
+    }
+    else
+    {
+        for (int i = 0; i < numOutputChannels; ++i)
+            zeromem (outputChannelData[i], (size_t) numSamples * sizeof (float));
+    }
+
+    if (testSound != nullptr)
+    {
+        auto numSamps = jmin (numSamples, testSound->getNumSamples() - testSoundPosition);
+        auto* src = testSound->getReadPointer (0, testSoundPosition);
+
+        for (int i = 0; i < numOutputChannels; ++i)
+            if (auto* dst = outputChannelData [i])
+                for (int j = 0; j < numSamps; ++j)
+                    dst[j] += src[j];
+
+        testSoundPosition += numSamps;
+
+        if (testSoundPosition >= testSound->getNumSamples())
+            testSound.reset();
+    }
+
+    outputLevelGetter->updateLevel (outputChannelData, numOutputChannels, numSamples);
+}
+
+void AudioDeviceManager::audioDeviceAboutToStartInt (AudioIODevice* const device)
+{
+    loadMeasurer.reset (device->getCurrentSampleRate(),
+                        device->getCurrentBufferSizeSamples());
+
+    updateCurrentSetup();
+
+    {
+        const ScopedLock sl (audioCallbackLock);
+
+        for (int i = callbacks.size(); --i >= 0;)
+            callbacks.getUnchecked (i)->audioDeviceAboutToStart (device);
+    }
+
+    sendChangeMessage();
+}
+
+void AudioDeviceManager::audioDeviceStoppedInt()
+{
+    sendChangeMessage();
+
+    const ScopedLock sl (audioCallbackLock);
+
+    loadMeasurer.reset();
+
+    for (int i = callbacks.size(); --i >= 0;)
+        callbacks.getUnchecked (i)->audioDeviceStopped();
+}
+
+void AudioDeviceManager::audioDeviceErrorInt (const String& message)
+{
+    const ScopedLock sl (audioCallbackLock);
+
+    for (int i = callbacks.size(); --i >= 0;)
+        callbacks.getUnchecked (i)->audioDeviceError (message);
+}
+
+double AudioDeviceManager::getCpuUsage() const
+{
+    return loadMeasurer.getLoadAsProportion();
+}
+
+//==============================================================================
+void AudioDeviceManager::setMidiInputDeviceEnabled (const String& identifier, bool enabled)
+{
+    if (enabled != isMidiInputDeviceEnabled (identifier))
+    {
+        if (enabled)
+        {
+            if (auto midiIn = MidiInput::openDevice (identifier, callbackHandler.get()))
+            {
+                enabledMidiInputs.push_back (std::move (midiIn));
+                enabledMidiInputs.back()->start();
+            }
+        }
+        else
+        {
+            auto removePredicate = [identifier] (const std::unique_ptr<MidiInput>& in) { return in->getIdentifier() == identifier; };
+            enabledMidiInputs.erase (std::remove_if (std::begin (enabledMidiInputs), std::end (enabledMidiInputs), removePredicate),
+                                     std::end (enabledMidiInputs));
+        }
+
+        updateXml();
+        sendChangeMessage();
+    }
+}
+
+bool AudioDeviceManager::isMidiInputDeviceEnabled (const String& identifier) const
+{
+    for (auto& mi : enabledMidiInputs)
+        if (mi->getIdentifier() == identifier)
+            return true;
+
+    return false;
+}
+
+void AudioDeviceManager::addMidiInputDeviceCallback (const String& identifier, MidiInputCallback* callbackToAdd)
+{
+    removeMidiInputDeviceCallback (identifier, callbackToAdd);
+
+    if (identifier.isEmpty() || isMidiInputDeviceEnabled (identifier))
+    {
+        const ScopedLock sl (midiCallbackLock);
+        midiCallbacks.add ({ identifier, callbackToAdd });
+    }
+}
+
+void AudioDeviceManager::removeMidiInputDeviceCallback (const String& identifier, MidiInputCallback* callbackToRemove)
+{
+    for (int i = midiCallbacks.size(); --i >= 0;)
+    {
+        auto& mc = midiCallbacks.getReference (i);
+
+        if (mc.callback == callbackToRemove && mc.deviceIdentifier == identifier)
+        {
+            const ScopedLock sl (midiCallbackLock);
+            midiCallbacks.remove (i);
+        }
+    }
+}
+
+void AudioDeviceManager::handleIncomingMidiMessageInt (MidiInput* source, const MidiMessage& message)
+{
+    if (! message.isActiveSense())
+    {
+        const ScopedLock sl (midiCallbackLock);
+
+        for (auto& mc : midiCallbacks)
+            if (mc.deviceIdentifier.isEmpty() || mc.deviceIdentifier == source->getIdentifier())
+                mc.callback->handleIncomingMidiMessage (source, message);
+    }
+}
+
+//==============================================================================
+void AudioDeviceManager::setDefaultMidiOutputDevice (const String& identifier)
+{
+    if (defaultMidiOutputDeviceInfo.identifier != identifier)
+    {
+        std::unique_ptr<MidiOutput> oldMidiPort;
+        Array<AudioIODeviceCallback*> oldCallbacks;
+
+        {
+            const ScopedLock sl (audioCallbackLock);
+            oldCallbacks.swapWith (callbacks);
+        }
+
+        if (currentAudioDevice != nullptr)
+            for (int i = oldCallbacks.size(); --i >= 0;)
+                oldCallbacks.getUnchecked (i)->audioDeviceStopped();
+
+        std::swap (oldMidiPort, defaultMidiOutput);
+
+        if (identifier.isNotEmpty())
+            defaultMidiOutput = MidiOutput::openDevice (identifier);
+
+        if (defaultMidiOutput != nullptr)
+            defaultMidiOutputDeviceInfo = defaultMidiOutput->getDeviceInfo();
+        else
+            defaultMidiOutputDeviceInfo = {};
+
+        if (currentAudioDevice != nullptr)
+            for (auto* c : oldCallbacks)
+                c->audioDeviceAboutToStart (currentAudioDevice.get());
+
+        {
+            const ScopedLock sl (audioCallbackLock);
+            oldCallbacks.swapWith (callbacks);
+        }
+
+        updateXml();
+        sendSynchronousChangeMessage();
+    }
+}
+
+//==============================================================================
+AudioDeviceManager::LevelMeter::LevelMeter() noexcept : level() {}
+
+void AudioDeviceManager::LevelMeter::updateLevel (const float* const* channelData, int numChannels, int numSamples) noexcept
+{
+    if (getReferenceCount() <= 1)
+        return;
+
+    auto localLevel = level.get();
+
+    if (numChannels > 0)
+    {
+        for (int j = 0; j < numSamples; ++j)
+        {
+            float s = 0;
+
+            for (int i = 0; i < numChannels; ++i)
+                s += std::abs (channelData[i][j]);
+
+            s /= (float) numChannels;
+
+            const float decayFactor = 0.99992f;
+
+            if (s > localLevel)
+                localLevel = s;
+            else if (localLevel > 0.001f)
+                localLevel *= decayFactor;
+            else
+                localLevel = 0;
+        }
+    }
+    else
+    {
+        localLevel = 0;
+    }
+
+    level = localLevel;
+}
+
+double AudioDeviceManager::LevelMeter::getCurrentLevel() const noexcept
+{
+    jassert (getReferenceCount() > 1);
+    return level.get();
+}
+
+void AudioDeviceManager::playTestSound()
+{
+    { // cunningly nested to swap, unlock and delete in that order.
+        std::unique_ptr<AudioBuffer<float>> oldSound;
+
+        {
+            const ScopedLock sl (audioCallbackLock);
+            std::swap (oldSound, testSound);
+        }
+    }
+
+    testSoundPosition = 0;
+
+    if (currentAudioDevice != nullptr)
+    {
+        auto sampleRate = currentAudioDevice->getCurrentSampleRate();
+        auto soundLength = (int) sampleRate;
+
+        double frequency = 440.0;
+        float amplitude = 0.5f;
+
+        auto phasePerSample = MathConstants<double>::twoPi / (sampleRate / frequency);
+
+        std::unique_ptr<AudioBuffer<float>> newSound (new AudioBuffer<float> (1, soundLength));
+
+        for (int i = 0; i < soundLength; ++i)
+            newSound->setSample (0, i, amplitude * (float) std::sin (i * phasePerSample));
+
+        newSound->applyGainRamp (0, 0, soundLength / 10, 0.0f, 1.0f);
+        newSound->applyGainRamp (0, soundLength - soundLength / 4, soundLength / 4, 1.0f, 0.0f);
+
+        {
+            const ScopedLock sl (audioCallbackLock);
+            std::swap (testSound, newSound);
+        }
+    }
+}
+
+int AudioDeviceManager::getXRunCount() const noexcept
+{
+    auto deviceXRuns = (currentAudioDevice != nullptr ? currentAudioDevice->getXRunCount() : -1);
+    return jmax (0, deviceXRuns) + loadMeasurer.getXRunCount();
+}
+
+//==============================================================================
+// Deprecated
+void AudioDeviceManager::setMidiInputEnabled (const String& name, const bool enabled)
+{
+    for (auto& device : MidiInput::getAvailableDevices())
+    {
+        if (device.name == name)
+        {
+            setMidiInputDeviceEnabled (device.identifier, enabled);
+            return;
+        }
+    }
+}
+
+bool AudioDeviceManager::isMidiInputEnabled (const String& name) const
+{
+    for (auto& device : MidiInput::getAvailableDevices())
+        if (device.name == name)
+            return isMidiInputDeviceEnabled (device.identifier);
+
+    return false;
+}
+
+void AudioDeviceManager::addMidiInputCallback (const String& name, MidiInputCallback* callbackToAdd)
+{
+    if (name.isEmpty())
+    {
+        addMidiInputDeviceCallback ({}, callbackToAdd);
+    }
+    else
+    {
+        for (auto& device : MidiInput::getAvailableDevices())
+        {
+            if (device.name == name)
+            {
+                addMidiInputDeviceCallback (device.identifier, callbackToAdd);
+                return;
+            }
+        }
+    }
+}
+
+void AudioDeviceManager::removeMidiInputCallback (const String& name, MidiInputCallback* callbackToRemove)
+{
+    if (name.isEmpty())
+    {
+        removeMidiInputDeviceCallback ({}, callbackToRemove);
+    }
+    else
+    {
+        for (auto& device : MidiInput::getAvailableDevices())
+        {
+            if (device.name == name)
+            {
+                removeMidiInputDeviceCallback (device.identifier, callbackToRemove);
+                return;
+            }
+        }
+    }
+}
+
+void AudioDeviceManager::setDefaultMidiOutput (const String& name)
+{
+    for (auto& device : MidiOutput::getAvailableDevices())
+    {
+        if (device.name == name)
+        {
+            setDefaultMidiOutputDevice (device.identifier);
+            return;
+        }
+    }
+}
+
+//==============================================================================
+//==============================================================================
+#if JUCE_UNIT_TESTS
+
+class AudioDeviceManagerTests final : public UnitTest
+{
+public:
+    AudioDeviceManagerTests() : UnitTest ("AudioDeviceManager", UnitTestCategories::audio) {}
+
+    void runTest() override
+    {
+        beginTest ("When the AudioDeviceSetup has non-empty device names, initialise uses the requested devices");
+        {
+            AudioDeviceManager manager;
+            initialiseManager (manager);
+
+            expectEquals (manager.getAvailableDeviceTypes().size(), 2);
+
+            AudioDeviceManager::AudioDeviceSetup setup;
+            setup.outputDeviceName = "z";
+            setup.inputDeviceName = "c";
+
+            expect (manager.initialise (2, 2, nullptr, true, String{}, &setup).isEmpty());
+
+            const auto& newSetup = manager.getAudioDeviceSetup();
+
+            expectEquals (newSetup.outputDeviceName, setup.outputDeviceName);
+            expectEquals (newSetup.inputDeviceName, setup.inputDeviceName);
+
+            expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+            expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 2);
+        }
+
+        beginTest ("When the AudioDeviceSetup has empty device names, initialise picks suitable default devices");
+        {
+            AudioDeviceManager manager;
+            initialiseManager (manager);
+
+            AudioDeviceManager::AudioDeviceSetup setup;
+
+            expect (manager.initialise (2, 2, nullptr, true, String{}, &setup).isEmpty());
+
+            const auto& newSetup = manager.getAudioDeviceSetup();
+
+            expectEquals (newSetup.outputDeviceName, String ("x"));
+            expectEquals (newSetup.inputDeviceName, String ("a"));
+
+            expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+            expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 2);
+        }
+
+        beginTest ("When the preferred device name matches an input and an output on the same type, that type is used");
+        {
+            AudioDeviceManager manager;
+            initialiseManagerWithDifferentDeviceNames (manager);
+
+            expect (manager.initialise (2, 2, nullptr, true, "bar *").isEmpty());
+
+            expectEquals (manager.getCurrentAudioDeviceType(), String ("bar"));
+
+            const auto& newSetup = manager.getAudioDeviceSetup();
+
+            expectEquals (newSetup.outputDeviceName, String ("bar out a"));
+            expectEquals (newSetup.inputDeviceName, String ("bar in a"));
+
+            expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+            expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 2);
+
+            expect (manager.getCurrentAudioDevice() != nullptr);
+        }
+
+        beginTest ("When the preferred device name matches either an input and an output, but not both, that type is used");
+        {
+            AudioDeviceManager manager;
+            initialiseManagerWithDifferentDeviceNames (manager);
+
+            expect (manager.initialise (2, 2, nullptr, true, "bar out b").isEmpty());
+
+            expectEquals (manager.getCurrentAudioDeviceType(), String ("bar"));
+
+            const auto& newSetup = manager.getAudioDeviceSetup();
+
+            expectEquals (newSetup.outputDeviceName, String ("bar out b"));
+            expectEquals (newSetup.inputDeviceName, String ("bar in a"));
+
+            expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+            expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 2);
+
+            expect (manager.getCurrentAudioDevice() != nullptr);
+        }
+
+        beginTest ("When the preferred device name does not match any inputs or outputs, defaults are used");
+        {
+            AudioDeviceManager manager;
+            initialiseManagerWithDifferentDeviceNames (manager);
+
+            expect (manager.initialise (2, 2, nullptr, true, "unmatchable").isEmpty());
+
+            expectEquals (manager.getCurrentAudioDeviceType(), String ("foo"));
+
+            const auto& newSetup = manager.getAudioDeviceSetup();
+
+            expectEquals (newSetup.outputDeviceName, String ("foo out a"));
+            expectEquals (newSetup.inputDeviceName, String ("foo in a"));
+
+            expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+            expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 2);
+
+            expect (manager.getCurrentAudioDevice() != nullptr);
+        }
+
+        beginTest ("When first device type has no devices, a device type with devices is used instead");
+        {
+            AudioDeviceManager manager;
+            initialiseManagerWithEmptyDeviceType (manager);
+
+            AudioDeviceManager::AudioDeviceSetup setup;
+
+            expect (manager.initialise (2, 2, nullptr, true, {}, &setup).isEmpty());
+
+            const auto& newSetup = manager.getAudioDeviceSetup();
+
+            expectEquals (newSetup.outputDeviceName, String ("x"));
+            expectEquals (newSetup.inputDeviceName, String ("a"));
+
+            expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+            expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 2);
+        }
+
+        beginTest ("If a device type has been explicitly set to a type with devices, "
+                   "initialisation should respect this choice");
+        {
+            AudioDeviceManager manager;
+            initialiseManagerWithEmptyDeviceType (manager);
+            manager.setCurrentAudioDeviceType (mockBName, true);
+
+            AudioDeviceManager::AudioDeviceSetup setup;
+            expect (manager.initialise (2, 2, nullptr, true, {}, &setup).isEmpty());
+
+            expectEquals (manager.getCurrentAudioDeviceType(), mockBName);
+        }
+
+        beginTest ("If a device type has been explicitly set to a type without devices, "
+                   "initialisation should pick a type with devices instead");
+        {
+            AudioDeviceManager manager;
+            initialiseManagerWithEmptyDeviceType (manager);
+            manager.setCurrentAudioDeviceType (emptyName, true);
+
+            AudioDeviceManager::AudioDeviceSetup setup;
+            expect (manager.initialise (2, 2, nullptr, true, {}, &setup).isEmpty());
+
+            expectEquals (manager.getCurrentAudioDeviceType(), mockAName);
+        }
+
+        beginTest ("Carry out a long sequence of configuration changes");
+        {
+            AudioDeviceManager manager;
+            initialiseManagerWithEmptyDeviceType    (manager);
+            initialiseWithDefaultDevices            (manager);
+            disableInputChannelsButLeaveDeviceOpen  (manager);
+            selectANewInputDevice                   (manager);
+            disableInputDevice                      (manager);
+            reenableInputDeviceWithNoChannels       (manager);
+            enableInputChannels                     (manager);
+            disableInputChannelsButLeaveDeviceOpen  (manager);
+            switchDeviceType                        (manager);
+            enableInputChannels                     (manager);
+            closeDeviceByRequestingEmptyNames       (manager);
+        }
+
+        beginTest ("AudioDeviceManager updates its current settings before notifying callbacks when device restarts itself");
+        {
+            AudioDeviceManager manager;
+            auto deviceType = std::make_unique<MockDeviceType> ("foo",
+                                                                StringArray { "foo in a", "foo in b" },
+                                                                StringArray { "foo out a", "foo out b" });
+            auto* ptr = deviceType.get();
+            manager.addAudioDeviceType (std::move (deviceType));
+
+            AudioDeviceManager::AudioDeviceSetup setup;
+            setup.sampleRate = 48000.0;
+            setup.bufferSize = 256;
+            setup.inputDeviceName = "foo in a";
+            setup.outputDeviceName = "foo out a";
+            setup.useDefaultInputChannels = true;
+            setup.useDefaultOutputChannels = true;
+            manager.setAudioDeviceSetup (setup, true);
+
+            const auto currentSetup = manager.getAudioDeviceSetup();
+            expectEquals (currentSetup.sampleRate, setup.sampleRate);
+            expectEquals (currentSetup.bufferSize, setup.bufferSize);
+
+            MockCallback callback;
+            manager.addAudioCallback (&callback);
+
+            constexpr auto newSr = 10000.0;
+            constexpr auto newBs = 1024;
+            auto numCalls = 0;
+
+            // Compilers disagree about whether newSr and newBs need to be captured
+            callback.aboutToStart = [&]
+            {
+                ++numCalls;
+                const auto current = manager.getAudioDeviceSetup();
+                expectEquals (current.sampleRate, newSr);
+                expectEquals (current.bufferSize, newBs);
+            };
+
+            ptr->restartDevices (newSr, newBs);
+            expectEquals (numCalls, 1);
+        }
+    }
+
+private:
+    void initialiseWithDefaultDevices (AudioDeviceManager& manager)
+    {
+        manager.initialiseWithDefaultDevices (2, 2);
+        const auto& setup = manager.getAudioDeviceSetup();
+
+        expectEquals (setup.inputChannels.countNumberOfSetBits(), 2);
+        expectEquals (setup.outputChannels.countNumberOfSetBits(), 2);
+
+        expect (setup.useDefaultInputChannels);
+        expect (setup.useDefaultOutputChannels);
+
+        expect (manager.getCurrentAudioDevice() != nullptr);
+    }
+
+    void disableInputChannelsButLeaveDeviceOpen (AudioDeviceManager& manager)
+    {
+        auto setup = manager.getAudioDeviceSetup();
+        setup.inputChannels.clear();
+        setup.useDefaultInputChannels = false;
+
+        expect (manager.setAudioDeviceSetup (setup, true).isEmpty());
+
+        const auto newSetup = manager.getAudioDeviceSetup();
+        expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 0);
+        expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+
+        expect (! newSetup.useDefaultInputChannels);
+        expect (newSetup.useDefaultOutputChannels);
+
+        expectEquals (newSetup.inputDeviceName, setup.inputDeviceName);
+        expectEquals (newSetup.outputDeviceName, setup.outputDeviceName);
+
+        expect (manager.getCurrentAudioDevice() != nullptr);
+    }
+
+    void selectANewInputDevice (AudioDeviceManager& manager)
+    {
+        auto setup = manager.getAudioDeviceSetup();
+        setup.inputDeviceName = "b";
+
+        expect (manager.setAudioDeviceSetup (setup, true).isEmpty());
+
+        const auto newSetup = manager.getAudioDeviceSetup();
+        expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 0);
+        expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+
+        expect (! newSetup.useDefaultInputChannels);
+        expect (newSetup.useDefaultOutputChannels);
+
+        expectEquals (newSetup.inputDeviceName, setup.inputDeviceName);
+        expectEquals (newSetup.outputDeviceName, setup.outputDeviceName);
+
+        expect (manager.getCurrentAudioDevice() != nullptr);
+    }
+
+    void disableInputDevice (AudioDeviceManager& manager)
+    {
+        auto setup = manager.getAudioDeviceSetup();
+        setup.inputDeviceName = "";
+
+        expect (manager.setAudioDeviceSetup (setup, true).isEmpty());
+
+        const auto newSetup = manager.getAudioDeviceSetup();
+        expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 0);
+        expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+
+        expect (! newSetup.useDefaultInputChannels);
+        expect (newSetup.useDefaultOutputChannels);
+
+        expectEquals (newSetup.inputDeviceName, setup.inputDeviceName);
+        expectEquals (newSetup.outputDeviceName, setup.outputDeviceName);
+
+        expect (manager.getCurrentAudioDevice() != nullptr);
+    }
+
+    void reenableInputDeviceWithNoChannels (AudioDeviceManager& manager)
+    {
+        auto setup = manager.getAudioDeviceSetup();
+        setup.inputDeviceName = "a";
+
+        expect (manager.setAudioDeviceSetup (setup, true).isEmpty());
+
+        const auto newSetup = manager.getAudioDeviceSetup();
+        expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 0);
+        expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+
+        expect (! newSetup.useDefaultInputChannels);
+        expect (newSetup.useDefaultOutputChannels);
+
+        expectEquals (newSetup.inputDeviceName, setup.inputDeviceName);
+        expectEquals (newSetup.outputDeviceName, setup.outputDeviceName);
+
+        expect (manager.getCurrentAudioDevice() != nullptr);
+    }
+
+    void enableInputChannels (AudioDeviceManager& manager)
+    {
+        auto setup = manager.getAudioDeviceSetup();
+        setup.inputDeviceName = manager.getCurrentDeviceTypeObject()->getDeviceNames (true)[0];
+        setup.inputChannels = 3;
+        setup.useDefaultInputChannels = false;
+
+        expect (manager.setAudioDeviceSetup (setup, true).isEmpty());
+
+        const auto newSetup = manager.getAudioDeviceSetup();
+        expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 2);
+        expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+
+        expect (! newSetup.useDefaultInputChannels);
+        expect (newSetup.useDefaultOutputChannels);
+
+        expectEquals (newSetup.inputDeviceName, setup.inputDeviceName);
+        expectEquals (newSetup.outputDeviceName, setup.outputDeviceName);
+
+        expect (manager.getCurrentAudioDevice() != nullptr);
+    }
+
+    void switchDeviceType (AudioDeviceManager& manager)
+    {
+        const auto oldSetup = manager.getAudioDeviceSetup();
+
+        expectEquals (manager.getCurrentAudioDeviceType(), String (mockAName));
+
+        manager.setCurrentAudioDeviceType (mockBName, true);
+
+        expectEquals (manager.getCurrentAudioDeviceType(), String (mockBName));
+
+        const auto newSetup = manager.getAudioDeviceSetup();
+
+        expect (newSetup.outputDeviceName.isNotEmpty());
+        // We had no channels enabled, which means we don't need to open a new input device
+        expect (newSetup.inputDeviceName.isEmpty());
+
+        expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 0);
+        expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+
+        expect (manager.getCurrentAudioDevice() != nullptr);
+    }
+
+    void closeDeviceByRequestingEmptyNames (AudioDeviceManager& manager)
+    {
+        auto setup = manager.getAudioDeviceSetup();
+        setup.inputDeviceName = "";
+        setup.outputDeviceName = "";
+
+        expect (manager.setAudioDeviceSetup (setup, true).isEmpty());
+
+        const auto newSetup = manager.getAudioDeviceSetup();
+        expectEquals (newSetup.inputChannels.countNumberOfSetBits(), 2);
+        expectEquals (newSetup.outputChannels.countNumberOfSetBits(), 2);
+
+        expect (newSetup.inputDeviceName.isEmpty());
+        expect (newSetup.outputDeviceName.isEmpty());
+
+        expect (manager.getCurrentAudioDevice() == nullptr);
+    }
+
+    const String mockAName = "mockA";
+    const String mockBName = "mockB";
+    const String emptyName = "empty";
+
+    struct Restartable
+    {
+        virtual ~Restartable() = default;
+        virtual void restart (double newSr, int newBs) = 0;
+    };
+
+    class MockDevice final : public AudioIODevice,
+                             private Restartable
+    {
+    public:
+        MockDevice (ListenerList<Restartable>& l, String typeNameIn, String outNameIn, String inNameIn)
+            : AudioIODevice ("mock", typeNameIn), listeners (l), outName (outNameIn), inName (inNameIn)
+        {
+            listeners.add (this);
+        }
+
+        ~MockDevice() override
+        {
+            listeners.remove (this);
+        }
+
+        StringArray getOutputChannelNames() override { return { "o1", "o2", "o3" }; }
+        StringArray getInputChannelNames()  override { return { "i1", "i2", "i3" }; }
+
+        Array<double> getAvailableSampleRates() override { return { 44100.0, 48000.0 }; }
+        Array<int> getAvailableBufferSizes() override { return { 128, 256 }; }
+        int getDefaultBufferSize() override { return 128; }
+
+        String open (const BigInteger& inputs, const BigInteger& outputs, double sr, int bs) override
+        {
+            inChannels = inputs;
+            outChannels = outputs;
+            sampleRate = sr;
+            blockSize = bs;
+            on = true;
+            return {};
+        }
+
+        void close() override { on = false; }
+        bool isOpen() override { return on; }
+
+        void start (AudioIODeviceCallback* c) override
+        {
+            callback = c;
+            callback->audioDeviceAboutToStart (this);
+            playing = true;
+        }
+
+        void stop() override
+        {
+            playing = false;
+            callback->audioDeviceStopped();
+        }
+
+        bool isPlaying() override { return playing; }
+
+        String getLastError() override { return {}; }
+        int getCurrentBufferSizeSamples() override { return blockSize; }
+        double getCurrentSampleRate() override { return sampleRate; }
+        int getCurrentBitDepth() override { return 16; }
+
+        BigInteger getActiveOutputChannels() const override { return outChannels; }
+        BigInteger getActiveInputChannels()  const override { return inChannels; }
+
+        int getOutputLatencyInSamples() override { return 0; }
+        int getInputLatencyInSamples() override { return 0; }
+
+    private:
+        void restart (double newSr, int newBs) override
+        {
+            stop();
+            close();
+            open (inChannels, outChannels, newSr, newBs);
+            start (callback);
+        }
+
+        ListenerList<Restartable>& listeners;
+        AudioIODeviceCallback* callback = nullptr;
+        String outName, inName;
+        BigInteger outChannels, inChannels;
+        double sampleRate = 0.0;
+        int blockSize = 0;
+        bool on = false, playing = false;
+    };
+
+    class MockDeviceType final : public AudioIODeviceType
+    {
+    public:
+        explicit MockDeviceType (String kind)
+            : MockDeviceType (std::move (kind), { "a", "b", "c" }, { "x", "y", "z" }) {}
+
+        MockDeviceType (String kind, StringArray inputNames, StringArray outputNames)
+            : AudioIODeviceType (std::move (kind)),
+              inNames (std::move (inputNames)),
+              outNames (std::move (outputNames)) {}
+
+        ~MockDeviceType() override
+        {
+            // A Device outlived its DeviceType!
+            jassert (listeners.isEmpty());
+        }
+
+        void scanForDevices() override {}
+
+        StringArray getDeviceNames (bool isInput) const override
+        {
+            return getNames (isInput);
+        }
+
+        int getDefaultDeviceIndex (bool) const override { return 0; }
+
+        int getIndexOfDevice (AudioIODevice* device, bool isInput) const override
+        {
+            return getNames (isInput).indexOf (device->getName());
+        }
+
+        bool hasSeparateInputsAndOutputs() const override { return true; }
+
+        AudioIODevice* createDevice (const String& outputName, const String& inputName) override
+        {
+            if (inNames.contains (inputName) || outNames.contains (outputName))
+                return new MockDevice (listeners, getTypeName(), outputName, inputName);
+
+            return nullptr;
+        }
+
+        // Call this to emulate the device restarting itself with new settings.
+        // This might happen e.g. when a user changes the ASIO settings.
+        void restartDevices (double newSr, int newBs)
+        {
+            listeners.call ([&] (auto& l) { return l.restart (newSr, newBs); });
+        }
+
+    private:
+        const StringArray& getNames (bool isInput) const { return isInput ? inNames : outNames; }
+
+        const StringArray inNames, outNames;
+        ListenerList<Restartable> listeners;
+    };
+
+    class MockCallback final : public AudioIODeviceCallback
+    {
+    public:
+        std::function<void()> callback;
+        std::function<void()> aboutToStart;
+        std::function<void()> stopped;
+        std::function<void()> error;
+
+        void audioDeviceIOCallbackWithContext (const float* const*,
+                                               int,
+                                               float* const*,
+                                               int,
+                                               int,
+                                               const AudioIODeviceCallbackContext&) override
+        {
+            NullCheckedInvocation::invoke (callback);
+        }
+
+        void audioDeviceAboutToStart (AudioIODevice*) override { NullCheckedInvocation::invoke (aboutToStart); }
+        void audioDeviceStopped()                     override { NullCheckedInvocation::invoke (stopped); }
+        void audioDeviceError (const String&)         override { NullCheckedInvocation::invoke (error); }
+    };
+
+    void initialiseManager (AudioDeviceManager& manager)
+    {
+        manager.addAudioDeviceType (std::make_unique<MockDeviceType> (mockAName));
+        manager.addAudioDeviceType (std::make_unique<MockDeviceType> (mockBName));
+    }
+
+    void initialiseManagerWithEmptyDeviceType (AudioDeviceManager& manager)
+    {
+        manager.addAudioDeviceType (std::make_unique<MockDeviceType> (emptyName, StringArray{}, StringArray{}));
+        initialiseManager (manager);
+    }
+
+    void initialiseManagerWithDifferentDeviceNames (AudioDeviceManager& manager)
+    {
+        manager.addAudioDeviceType (std::make_unique<MockDeviceType> ("foo",
+                                                                      StringArray { "foo in a", "foo in b" },
+                                                                      StringArray { "foo out a", "foo out b" }));
+
+        manager.addAudioDeviceType (std::make_unique<MockDeviceType> ("bar",
+                                                                      StringArray { "bar in a", "bar in b" },
+                                                                      StringArray { "bar out a", "bar out b" }));
+    }
+};
+
+static AudioDeviceManagerTests audioDeviceManagerTests;
+
+#endif
+
+} // namespace juce