Revision control
++ // Copyright (C) 2026 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ #include "qcoreaudioaggregatedevice_p.h"
++
++ #include <QtMultimedia/qmediadevices.h>
++ #include <QtMultimedia/private/qmultimedia_ranges_p.h>
++ #include <QtCore/qcoreapplication.h>
++ #include <QtCore/qdeadlinetimer.h>
++ #include <QtCore/qthread.h>
++ #include <QtCore/quuid.h>
++ #include <QtCore/private/qcore_mac_p.h>
++
++ #include <CoreAudio/CoreAudio.h>
++ #include <CoreFoundation/CoreFoundation.h>
++
++ #include <atomic>
++ #include <optional>
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++ using namespace std::chrono_literals;
++
++ namespace {
++
++ constexpr AudioObjectPropertyAddress isAliveAddress{
++ kAudioDevicePropertyDeviceIsAlive,
++ kAudioObjectPropertyScopeGlobal,
++ kAudioObjectPropertyElementMain,
++ };
++
++ std::optional<QString> defaultDeviceUid(QCoreAudioAggregateDevice::Direction direction)
++ {
++ const AudioObjectPropertyAddress defaultDeviceAddress{
++ direction == QCoreAudioAggregateDevice::Direction::Output
++ ? kAudioHardwarePropertyDefaultOutputDevice
++ : kAudioHardwarePropertyDefaultInputDevice,
++ kAudioObjectPropertyScopeGlobal,
++ kAudioObjectPropertyElementMain,
++ };
++
++ AudioObjectID deviceId = kAudioObjectUnknown;
++ UInt32 size = sizeof(deviceId);
++ if (AudioObjectGetPropertyData(kAudioObjectSystemObject, &defaultDeviceAddress, 0, nullptr,
++ &size, &deviceId)
++ != noErr
++ || deviceId == kAudioObjectUnknown)
++ return std::nullopt;
++
++ const AudioObjectPropertyAddress uidAddress{
++ kAudioDevicePropertyDeviceUID,
++ kAudioObjectPropertyScopeGlobal,
++ kAudioObjectPropertyElementMain,
++ };
++ CFStringRef uid = nullptr;
++ size = sizeof(uid);
++ if (AudioObjectGetPropertyData(deviceId, &uidAddress, 0, nullptr, &size, &uid) != noErr || !uid)
++ return std::nullopt;
++
++ QCFType<CFStringRef> ownedUid{ uid };
++ return QString::fromCFString(ownedUid);
++ }
++
++ OSStatus onPropertyChanged(AudioObjectID, UInt32 numberOfAddresses,
++ const AudioObjectPropertyAddress *addresses, void *clientData)
++ {
++ auto *notifications = static_cast<std::atomic<int> *>(clientData);
++ for (UInt32 index = 0; index != numberOfAddresses; ++index) {
++ if (addresses[index].mSelector == kAudioDevicePropertyDeviceIsAlive)
++ notifications->fetch_add(1);
++ }
++ return noErr;
++ }
++
++ } // namespace
++
++ struct QCoreAudioAggregateDevice::Private
++ {
++ ~Private()
++ {
++ if (id == kAudioObjectUnknown)
++ return;
++ if (listenerInstalled)
++ AudioObjectRemovePropertyListener(id, &isAliveAddress, onPropertyChanged,
++ &isAliveNotifications);
++ AudioHardwareDestroyAggregateDevice(id);
++ }
++
++ AudioObjectID id = kAudioObjectUnknown;
++ QString name;
++ std::atomic<int> isAliveNotifications = 0;
++ bool listenerInstalled = false;
++ };
++
++ QCoreAudioAggregateDevice::QCoreAudioAggregateDevice(std::unique_ptr<Private> priv)
++ : d{ std::move(priv) }
++ {
++ }
++
++ QCoreAudioAggregateDevice::~QCoreAudioAggregateDevice() = default;
++
++ std::unique_ptr<QCoreAudioAggregateDevice> QCoreAudioAggregateDevice::create(Direction direction)
++ {
++ const std::optional<QString> subDeviceUid = defaultDeviceUid(direction);
++ if (!subDeviceUid)
++ return nullptr;
++
++ // Fresh name/UID per attempt: parallel ctest processes create aggregates concurrently,
++ // so a reused UID could collide with a device owned by another test process.
++ constexpr int maxAttempts = 3;
++ for (int attempt = 0; attempt != maxAttempts; ++attempt) {
++ const QString uniqueSuffix = QUuid::createUuid().toString(QUuid::Id128);
++ const QString name = u"QtTestAggregate"_s + uniqueSuffix;
++ const QString uid = u"io.qt.test.aggregate."_s + uniqueSuffix;
++
++ QCFType<CFMutableDictionaryRef> description{ CFDictionaryCreateMutable(
++ kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,
++ &kCFTypeDictionaryValueCallBacks) };
++ QCFType<CFStringRef> cfName = name.toCFString();
++ QCFType<CFStringRef> cfUid = uid.toCFString();
++ QCFType<CFStringRef> cfSubDeviceUid = subDeviceUid->toCFString();
++ const int isPrivate = 1;
++ QCFType<CFNumberRef> cfIsPrivate =
++ CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &isPrivate);
++
++ QCFType<CFMutableDictionaryRef> subDevice{
++ CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,
++ &kCFTypeDictionaryValueCallBacks),
++ };
++ CFDictionaryAddValue(subDevice, CFSTR(kAudioSubDeviceUIDKey), cfSubDeviceUid);
++ QCFType<CFMutableArrayRef> subDevices{
++ CFArrayCreateMutable(kCFAllocatorDefault, 1, &kCFTypeArrayCallBacks),
++ };
++ CFArrayAppendValue(subDevices, subDevice);
++
++ CFDictionaryAddValue(description, CFSTR(kAudioAggregateDeviceNameKey), cfName);
++ CFDictionaryAddValue(description, CFSTR(kAudioAggregateDeviceUIDKey), cfUid);
++ CFDictionaryAddValue(description, CFSTR(kAudioAggregateDeviceIsPrivateKey), cfIsPrivate);
++ CFDictionaryAddValue(description, CFSTR(kAudioAggregateDeviceSubDeviceListKey), subDevices);
++
++ AudioObjectID id = kAudioObjectUnknown;
++ if (AudioHardwareCreateAggregateDevice(description, &id) == noErr
++ && id != kAudioObjectUnknown) {
++ auto priv = std::make_unique<Private>();
++ priv->id = id;
++ priv->name = name;
++
++ return std::unique_ptr<QCoreAudioAggregateDevice>{
++ new QCoreAudioAggregateDevice{ std::move(priv) },
++ };
++ }
++ }
++
++ return nullptr;
++ }
++
++ std::optional<QAudioDevice>
++ QCoreAudioAggregateDevice::waitForQtDevice(std::chrono::milliseconds timeout) const
++ {
++ namespace ranges = QtMultimediaPrivate::ranges;
++
++ QDeadlineTimer deadline{ timeout };
++ do {
++ QCoreApplication::processEvents(QEventLoop::AllEvents, 5);
++
++ for (auto devices : { QMediaDevices::audioOutputs(), QMediaDevices::audioInputs() }) {
++ const auto it = ranges::find_if(devices, [&](const QAudioDevice &device) {
++ return device.description() == d->name;
++ });
++ if (it != devices.end())
++ return *it;
++ }
++
++ std::this_thread::sleep_for(2ms);
++ } while (!deadline.hasExpired());
++
++ return std::nullopt;
++ }
++
++ bool QCoreAudioAggregateDevice::destroyAndWaitForDisconnectNotification(
++ std::chrono::milliseconds timeout)
++ {
++ const AudioObjectID id = d->id;
++ if (id == kAudioObjectUnknown)
++ return false;
++
++ d->isAliveNotifications = 0;
++
++ if (AudioObjectAddPropertyListener(id, &isAliveAddress, onPropertyChanged,
++ &d->isAliveNotifications)
++ != noErr)
++ return false;
++ d->listenerInstalled = true;
++
++ if (AudioHardwareDestroyAggregateDevice(id) != noErr) {
++ AudioObjectRemovePropertyListener(id, &isAliveAddress, onPropertyChanged,
++ &d->isAliveNotifications);
++ d->listenerInstalled = false;
++ return false;
++ }
++ // The HAL drops listeners with the destroyed device
++ d->id = kAudioObjectUnknown;
++ d->listenerInstalled = false;
++
++ // Block without running the Qt event loop, so QtMultimedia's disconnect handling stays queued
++ QDeadlineTimer deadline{ timeout };
++ while (d->isAliveNotifications.load() == 0) {
++ if (deadline.hasExpired())
++ return false;
++ std::this_thread::sleep_for(1ms);
++ }
++
++ // The HAL notifies listeners in registration order on one thread. QtMultimedia's listener
++ // fulfills the promise that posts the continuation, so wait until it has run.
++ std::this_thread::sleep_for(20ms);
++ return true;
++ }
++
++ QT_END_NAMESPACE