Revision control

++ // Copyright (C) 2022 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "qbluetoothdevicediscoveryagent_p.h"
++ #include "qbluetoothdevicediscoveryagent.h"
++
++ #include "darwin/btledeviceinquiry_p.h"
++
++ #ifdef Q_OS_MACOS
++ #include "darwin/btdeviceinquiry_p.h"
++ #include "darwin/btsdpinquiry_p.h"
++
++ #include <IOBluetooth/IOBluetooth.h>
++ #endif // Q_OS_MACOS
++
++ #include "qbluetoothdeviceinfo.h"
++ #include "darwin/btnotifier_p.h"
++ #include "darwin/btutility_p.h"
++ #include "darwin/uistrings_p.h"
++ #include "qbluetoothhostinfo.h"
++ #include "darwin/uistrings_p.h"
++ #include "qbluetoothaddress.h"
++ #include "darwin/btraii_p.h"
++ #include "qbluetoothuuid.h"
++
++ #include <QtCore/qloggingcategory.h>
++ #include <QtCore/qcoreapplication.h>
++ #include <QtCore/qpermissions.h>
++ #include <QtCore/qvector.h>
++ #include <QtCore/qglobal.h>
++ #include <QtCore/qstring.h>
++ #include <QtCore/qdebug.h>
++
++ #include <Foundation/Foundation.h>
++
++ #include <CoreBluetooth/CoreBluetooth.h>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace
++ {
++
++ void registerQDeviceDiscoveryMetaType()
++ {
++ static bool initDone = false;
++ if (!initDone) {
++ qRegisterMetaType<QBluetoothDeviceInfo>();
++ qRegisterMetaType<QBluetoothDeviceDiscoveryAgent::Error>();
++ initDone = true;
++ }
++ }
++
++ } //namespace
++
++ QBluetoothDeviceDiscoveryAgentPrivate::QBluetoothDeviceDiscoveryAgentPrivate(const QBluetoothAddress &adapter,
++ QBluetoothDeviceDiscoveryAgent *q) :
++ adapterAddress(adapter),
++ agentState(NonActive),
++ lowEnergySearchTimeout(DarwinBluetooth::defaultLEScanTimeoutMS),
++ #ifdef Q_OS_MACOS
++ requestedMethods(QBluetoothDeviceDiscoveryAgent::ClassicMethod | QBluetoothDeviceDiscoveryAgent::LowEnergyMethod),
++ #else
++ requestedMethods(QBluetoothDeviceDiscoveryAgent::ClassicMethod),
++ #endif // Q_OS_MACOS
++ q_ptr(q)
++ {
++ registerQDeviceDiscoveryMetaType();
++
++ Q_ASSERT_X(q != nullptr, Q_FUNC_INFO, "invalid q_ptr (null)");
++ }
++
++ QBluetoothDeviceDiscoveryAgentPrivate::~QBluetoothDeviceDiscoveryAgentPrivate()
++ {
++ if (inquiryLE && agentState != NonActive) {
++ // We want the LE scan to stop as soon as possible.
++ if (dispatch_queue_t leQueue = DarwinBluetooth::qt_LE_queue()) {
++ // Local variable to be retained ...
++ DarwinBTLEDeviceInquiry *inq = inquiryLE.getAs<DarwinBTLEDeviceInquiry>();
++ dispatch_sync(leQueue, ^{
++ [inq stop];
++ });
++ }
++ }
++ }
++
++ bool QBluetoothDeviceDiscoveryAgentPrivate::isActive() const
++ {
++ if (startPending)
++ return true;
++
++ if (stopPending)
++ return false;
++
++ return agentState != NonActive;
++ }
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::start(QBluetoothDeviceDiscoveryAgent::DiscoveryMethods methods)
++ {
++ using namespace DarwinBluetooth;
++
++ Q_ASSERT(!isActive());
++ Q_ASSERT(methods & (QBluetoothDeviceDiscoveryAgent::ClassicMethod
++ | QBluetoothDeviceDiscoveryAgent::LowEnergyMethod));
++
++ #ifdef Q_OS_MACOS
++ if (!controller) {
++ IOBluetoothHostController *hostController = [IOBluetoothHostController defaultController];
++ if (!hostController) {
++ qCWarning(QT_BT_DARWIN) << "No default Bluetooth controller found";
++ setError(QBluetoothDeviceDiscoveryAgent::InvalidBluetoothAdapterError);
++ emit q_ptr->errorOccurred(lastError);
++ return;
++ } else if ([hostController powerState] != kBluetoothHCIPowerStateON) {
++ qCWarning(QT_BT_DARWIN) << "Default Bluetooth controller is OFF";
++ setError(QBluetoothDeviceDiscoveryAgent::PoweredOffError);
++ emit q_ptr->errorOccurred(lastError);
++ return;
++ } else if (!adapterAddress.isNull()) {
++ // If user has provided the local address, check that it matches with the actual
++ NSString *const hciAddress = [hostController addressAsString];
++ if (adapterAddress != QBluetoothAddress(QString::fromNSString(hciAddress))) {
++ qCWarning(QT_BT_DARWIN) << "Provided address" << adapterAddress
++ << "does not match with adapter:" << hciAddress;
++ setError(QBluetoothDeviceDiscoveryAgent::InvalidBluetoothAdapterError);
++ emit q_ptr->errorOccurred(lastError);
++ return;
++ }
++ }
++ controller.reset(hostController, DarwinBluetooth::RetainPolicy::doInitialRetain);
++ }
++ #endif // Q_OS_MACOS
++
++ // To be able to scan for devices, iOS requires Info.plist containing
++ // NSBluetoothAlwaysUsageDescription entry with a string, explaining
++ // the usage of Bluetooth interface. macOS also requires this description,
++ // starting from Monterey.
++
++ // No Classic on iOS, and Classic does not require a description on macOS:
++ if (methods.testFlag(QBluetoothDeviceDiscoveryAgent::LowEnergyMethod)) {
++ const auto permissionStatus = qApp->checkPermission(QBluetoothPermission{});
++ if (permissionStatus != Qt::PermissionStatus::Granted) {
++ qCWarning(QT_BT_DARWIN,
++ "Use of Bluetooth LE requires explicitly requested permissions.");
++ setError(QBluetoothDeviceDiscoveryAgent::MissingPermissionsError);
++ emit q_ptr->errorOccurred(lastError);
++ // Arguably, Classic scan is still possible, but let's keep the logic
++ // simple.
++ return;
++ }
++ }
++
++ requestedMethods = methods;
++
++ if (stopPending) {
++ startPending = true;
++ return;
++ }
++
++ // This function (re)starts the scan(s) from the scratch;
++ // starting from Classic if it's in 'methods' (or LE scan if not).
++
++ agentState = NonActive;
++ discoveredDevices.clear();
++ setError(QBluetoothDeviceDiscoveryAgent::NoError);
++ #ifdef Q_OS_MACOS
++ if (requestedMethods & QBluetoothDeviceDiscoveryAgent::ClassicMethod)
++ return startClassic();
++ #endif // Q_OS_MACOS
++
++ startLE();
++ }
++
++ #ifdef Q_OS_MACOS
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::startClassic()
++ {
++ Q_ASSERT(!isActive());
++ Q_ASSERT(lastError == QBluetoothDeviceDiscoveryAgent::NoError);
++ Q_ASSERT(requestedMethods & QBluetoothDeviceDiscoveryAgent::ClassicMethod);
++ Q_ASSERT(agentState == NonActive);
++
++ DarwinBluetooth::qt_test_iobluetooth_runloop();
++
++ if (!inquiry) {
++ // The first Classic scan for this DDA.
++ inquiry.reset([[DarwinBTClassicDeviceInquiry alloc] initWithDelegate:this],
++ DarwinBluetooth::RetainPolicy::noInitialRetain);
++
++ if (!inquiry) {
++ qCCritical(QT_BT_DARWIN) << "failed to initialize an Classic device inquiry";
++ setError(QBluetoothDeviceDiscoveryAgent::UnknownError,
++ QCoreApplication::translate(DEV_DISCOVERY, DD_NOT_STARTED));
++ emit q_ptr->errorOccurred(lastError);
++ return;
++ }
++ }
++
++ agentState = ClassicScan;
++
++ const IOReturn res = [inquiry.getAs<DarwinBTClassicDeviceInquiry>() start];
++ if (res != kIOReturnSuccess) {
++ setError(res, QCoreApplication::translate(DEV_DISCOVERY, DD_NOT_STARTED));
++ agentState = NonActive;
++ emit q_ptr->errorOccurred(lastError);
++ }
++ }
++
++ #endif // Q_OS_MACOS
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::startLE()
++ {
++ Q_ASSERT(lastError != QBluetoothDeviceDiscoveryAgent::InvalidBluetoothAdapterError);
++ Q_ASSERT(requestedMethods & QBluetoothDeviceDiscoveryAgent::LowEnergyMethod);
++
++ using namespace DarwinBluetooth;
++
++ std::unique_ptr<LECBManagerNotifier> notifier = std::make_unique<LECBManagerNotifier>();
++ // Connections:
++ using ErrMemFunPtr = void (LECBManagerNotifier::*)(QBluetoothDeviceDiscoveryAgent::Error);
++ notifier->connect(notifier.get(), ErrMemFunPtr(&LECBManagerNotifier::CBManagerError),
++ this, &QBluetoothDeviceDiscoveryAgentPrivate::LEinquiryError);
++ notifier->connect(notifier.get(), &LECBManagerNotifier::LEnotSupported,
++ this, &QBluetoothDeviceDiscoveryAgentPrivate::LEnotSupported);
++ notifier->connect(notifier.get(), &LECBManagerNotifier::discoveryFinished,
++ this, &QBluetoothDeviceDiscoveryAgentPrivate::LEinquiryFinished);
++ using DeviceMemFunPtr = void (QBluetoothDeviceDiscoveryAgentPrivate::*)(const QBluetoothDeviceInfo &);
++ notifier->connect(notifier.get(), &LECBManagerNotifier::deviceDiscovered,
++ this, DeviceMemFunPtr(&QBluetoothDeviceDiscoveryAgentPrivate::deviceFound));
++
++ // Check queue and create scanner:
++ inquiryLE.reset([[DarwinBTLEDeviceInquiry alloc] initWithNotifier:notifier.get()],
++ DarwinBluetooth::RetainPolicy::noInitialRetain);
++ if (inquiryLE)
++ notifier.release(); // Whatever happens next, inquiryLE is already the owner ...
++
++ dispatch_queue_t leQueue(qt_LE_queue());
++ if (!leQueue || !inquiryLE) {
++ setError(QBluetoothDeviceDiscoveryAgent::UnknownError,
++ QCoreApplication::translate(DEV_DISCOVERY, DD_NOT_STARTED_LE));
++ agentState = NonActive;
++ emit q_ptr->errorOccurred(lastError);
++ return;
++ }
++
++ // Now start in on LE queue:
++ agentState = LEScan;
++ // We need the local variable so that it's retained ...
++ DarwinBTLEDeviceInquiry *inq = inquiryLE.getAs<DarwinBTLEDeviceInquiry>();
++ dispatch_async(leQueue, ^{
++ [inq startWithTimeout:lowEnergySearchTimeout];
++ });
++ }
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::stop()
++ {
++ Q_ASSERT_X(isActive(), Q_FUNC_INFO, "called whithout active inquiry");
++ Q_ASSERT_X(lastError != QBluetoothDeviceDiscoveryAgent::InvalidBluetoothAdapterError,
++ Q_FUNC_INFO, "called with invalid bluetooth adapter");
++
++ using namespace DarwinBluetooth;
++
++ const bool prevStart = startPending;
++ startPending = false;
++ stopPending = true;
++
++ setError(QBluetoothDeviceDiscoveryAgent::NoError);
++
++ #ifdef Q_OS_MACOS
++ if (agentState == ClassicScan) {
++ const IOReturn res = [inquiry.getAs<DarwinBTClassicDeviceInquiry>() stop];
++ if (res != kIOReturnSuccess) {
++ qCWarning(QT_BT_DARWIN) << "failed to stop";
++ startPending = prevStart;
++ stopPending = false;
++ setError(res, QCoreApplication::translate(DEV_DISCOVERY, DD_NOT_STOPPED));
++ emit q_ptr->errorOccurred(lastError);
++ }
++ } else {
++ #else
++ {
++ Q_UNUSED(prevStart);
++ #endif // Q_OS_MACOS
++ dispatch_queue_t leQueue(qt_LE_queue());
++ Q_ASSERT(leQueue);
++ // We need the local variable so that it's retained ...
++ DarwinBTLEDeviceInquiry *inq = inquiryLE.getAs<DarwinBTLEDeviceInquiry>();
++ dispatch_sync(leQueue, ^{
++ [inq stop];
++ });
++ // We consider LE scan to be stopped immediately and
++ // do not care about this LEDeviceInquiry object anymore.
++ LEinquiryFinished();
++ }
++ }
++
++ #ifdef Q_OS_MACOS
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::inquiryFinished()
++ {
++ // The subsequent start(LE) function (if any)
++ // will (re)set the correct state.
++ agentState = NonActive;
++
++ if (stopPending && !startPending) {
++ stopPending = false;
++ emit q_ptr->canceled();
++ } else if (startPending) {
++ startPending = false;
++ stopPending = false;
++ start(requestedMethods);
++ } else {
++ // We can be here _only_ if a classic scan
++ // finished in a normal way (not cancelled)
++ // and requestedMethods includes LowEnergyMethod.
++ // startLE() will take care of old devices
++ // not supporting Bluetooth 4.0.
++ if (requestedMethods & QBluetoothDeviceDiscoveryAgent::LowEnergyMethod)
++ startLE();
++ else
++ emit q_ptr->finished();
++ }
++ }
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::error(IOReturn error)
++ {
++ startPending = false;
++ stopPending = false;
++
++ setError(error);
++
++ emit q_ptr->errorOccurred(lastError);
++ }
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::classicDeviceFound(void *obj)
++ {
++ auto device = static_cast<IOBluetoothDevice *>(obj);
++ Q_ASSERT_X(device, Q_FUNC_INFO, "invalid IOBluetoothDevice (nil)");
++
++ Q_ASSERT_X(agentState == ClassicScan, Q_FUNC_INFO,
++ "invalid agent state (expected classic scan)");
++
++ QT_BT_MAC_AUTORELEASEPOOL;
++
++ // Let's collect some info about this device:
++ const QBluetoothAddress deviceAddress(DarwinBluetooth::qt_address([device getAddress]));
++ if (deviceAddress.isNull()) {
++ qCWarning(QT_BT_DARWIN) << "invalid Bluetooth address";
++ return;
++ }
++
++ QString deviceName;
++ if (device.name)
++ deviceName = QString::fromNSString(device.name);
++
++ const auto classOfDevice = qint32(device.classOfDevice);
++
++ QBluetoothDeviceInfo deviceInfo(deviceAddress, deviceName, classOfDevice);
++ deviceInfo.setCoreConfigurations(QBluetoothDeviceInfo::BaseRateCoreConfiguration);
++ deviceInfo.setRssi(device.RSSI);
++
++ const QList<QBluetoothUuid> uuids(DarwinBluetooth::extract_services_uuids(device));
++ deviceInfo.setServiceUuids(uuids);
++
++ deviceFound(deviceInfo);
++ }
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::setError(IOReturn error, const QString &text)
++ {
++ if (error == kIOReturnSuccess)
++ setError(QBluetoothDeviceDiscoveryAgent::NoError, text);
++ else if (error == kIOReturnNoPower)
++ setError(QBluetoothDeviceDiscoveryAgent::PoweredOffError, text);
++ else
++ setError(QBluetoothDeviceDiscoveryAgent::UnknownError, text);
++ }
++
++ #endif // Q_OS_MACOS
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::setError(QBluetoothDeviceDiscoveryAgent::Error error, const QString &text)
++ {
++ lastError = error;
++
++ if (!text.isEmpty()) {
++ errorString = text;
++ } else {
++ switch (lastError) {
++ case QBluetoothDeviceDiscoveryAgent::NoError:
++ errorString = QString();
++ break;
++ case QBluetoothDeviceDiscoveryAgent::PoweredOffError:
++ errorString = QCoreApplication::translate(DEV_DISCOVERY, DD_POWERED_OFF);
++ break;
++ case QBluetoothDeviceDiscoveryAgent::InvalidBluetoothAdapterError:
++ errorString = QCoreApplication::translate(DEV_DISCOVERY, DD_INVALID_ADAPTER);
++ break;
++ case QBluetoothDeviceDiscoveryAgent::InputOutputError:
++ errorString = QCoreApplication::translate(DEV_DISCOVERY, DD_IO);
++ break;
++ case QBluetoothDeviceDiscoveryAgent::UnsupportedPlatformError:
++ errorString = QCoreApplication::translate(DEV_DISCOVERY, DD_NOTSUPPORTED);
++ break;
++ case QBluetoothDeviceDiscoveryAgent::MissingPermissionsError:
++ errorString = QCoreApplication::translate(DEV_DISCOVERY, DD_MISSING_PERMISSION);
++ break;
++ case QBluetoothDeviceDiscoveryAgent::UnknownError:
++ default:
++ errorString = QCoreApplication::translate(DEV_DISCOVERY, DD_UNKNOWN_ERROR);
++ }
++ }
++ }
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::LEinquiryError(QBluetoothDeviceDiscoveryAgent::Error error)
++ {
++ Q_ASSERT(error == QBluetoothDeviceDiscoveryAgent::PoweredOffError
++ || error == QBluetoothDeviceDiscoveryAgent::UnsupportedDiscoveryMethod
++ || error == QBluetoothDeviceDiscoveryAgent::MissingPermissionsError);
++
++ inquiryLE.reset();
++
++ startPending = false;
++ stopPending = false;
++ agentState = NonActive;
++ setError(error);
++ emit q_ptr->errorOccurred(lastError);
++ }
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::LEnotSupported()
++ {
++ qCDebug(QT_BT_DARWIN) << "no Bluetooth LE support";
++
++ #ifdef Q_OS_MACOS
++ if (requestedMethods & QBluetoothDeviceDiscoveryAgent::ClassicMethod) {
++ // Having both Classic | LE means this is not an error.
++ LEinquiryFinished();
++ } else {
++ // In the past this was never an error, that's why we have
++ // LEnotSupported as a special method. But now, since
++ // we can have separate Classic/LE scans, we have to report it
++ // as UnsupportedDiscoveryMethod.
++ LEinquiryError(QBluetoothDeviceDiscoveryAgent::UnsupportedDiscoveryMethod);
++ }
++ #else
++ inquiryLE.reset();
++ startPending = false;
++ stopPending = false;
++ setError(QBluetoothDeviceDiscoveryAgent::UnsupportedPlatformError);
++ emit q_ptr->errorOccurred(lastError);
++ #endif
++ }
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::LEinquiryFinished()
++ {
++ // The same logic as in inquiryFinished, but does not start LE scan.
++ agentState = NonActive;
++ inquiryLE.reset();
++
++ if (stopPending && !startPending) {
++ stopPending = false;
++ emit q_ptr->canceled();
++ } else if (startPending) {
++ startPending = false;
++ stopPending = false;
++ start(requestedMethods); //Start again.
++ } else {
++ emit q_ptr->finished();
++ }
++ }
++
++ void QBluetoothDeviceDiscoveryAgentPrivate::deviceFound(const QBluetoothDeviceInfo &newDeviceInfo)
++ {
++ // Core Bluetooth does not allow us to access addresses, we have to use uuid instead.
++ // This uuid has nothing to do with uuids in Bluetooth in general (it's generated by
++ // Apple's framework using some algorithm), but it's a 128-bit uuid after all.
++ const bool isLE =
++ #ifdef Q_OS_MACOS
++ newDeviceInfo.coreConfigurations() == QBluetoothDeviceInfo::LowEnergyCoreConfiguration;
++ #else
++ true;
++ #endif // Q_OS_MACOS
++ for (qsizetype i = 0, e = discoveredDevices.size(); i < e; ++i) {
++ if (isLE) {
++ if (discoveredDevices[i].deviceUuid() == newDeviceInfo.deviceUuid()) {
++ QBluetoothDeviceInfo::Fields updatedFields = QBluetoothDeviceInfo::Field::None;
++ if (discoveredDevices[i].rssi() != newDeviceInfo.rssi()) {
++ qCDebug(QT_BT_DARWIN) << "Updating RSSI for" << newDeviceInfo.address()
++ << newDeviceInfo.rssi();
++ discoveredDevices[i].setRssi(newDeviceInfo.rssi());
++ updatedFields.setFlag(QBluetoothDeviceInfo::Field::RSSI);
++ }
++
++ if (discoveredDevices[i].manufacturerData() != newDeviceInfo.manufacturerData()) {
++ qCDebug(QT_BT_DARWIN) << "Updating manufacturer data for" << newDeviceInfo.address();
++ const QList<quint16> keys = newDeviceInfo.manufacturerIds();
++ for (auto key: keys)
++ discoveredDevices[i].setManufacturerData(key, newDeviceInfo.manufacturerData(key));
++ updatedFields.setFlag(QBluetoothDeviceInfo::Field::ManufacturerData);
++ }
++
++ if (discoveredDevices[i].serviceData() != newDeviceInfo.serviceData()) {
++ qCDebug(QT_BT_DARWIN) << "Updating service data for" << newDeviceInfo.address();
++ const QList<QBluetoothUuid> keys = newDeviceInfo.serviceIds();
++ for (auto key : keys)
++ discoveredDevices[i].setServiceData(key, newDeviceInfo.serviceData(key));
++ updatedFields.setFlag(QBluetoothDeviceInfo::Field::ServiceData);
++ }
++
++ if (lowEnergySearchTimeout > 0) {
++ if (discoveredDevices[i] != newDeviceInfo) {
++ discoveredDevices.replace(i, newDeviceInfo);
++ emit q_ptr->deviceDiscovered(newDeviceInfo);
++ } else {
++ if (!updatedFields.testFlag(QBluetoothDeviceInfo::Field::None))
++ emit q_ptr->deviceUpdated(discoveredDevices[i], updatedFields);
++ }
++
++ return;
++ }
++
++ discoveredDevices.replace(i, newDeviceInfo);
++ emit q_ptr->deviceDiscovered(newDeviceInfo);
++
++ if (!updatedFields.testFlag(QBluetoothDeviceInfo::Field::None))
++ emit q_ptr->deviceUpdated(discoveredDevices[i], updatedFields);
++
++ return;
++ }
++ } else {
++ #ifdef Q_OS_MACOS
++ if (discoveredDevices[i].address() == newDeviceInfo.address()) {
++ if (discoveredDevices[i] == newDeviceInfo)
++ return;
++
++ discoveredDevices.replace(i, newDeviceInfo);
++ emit q_ptr->deviceDiscovered(newDeviceInfo);
++ return;
++ }
++ #else
++ Q_UNREACHABLE();
++ #endif // Q_OS_MACOS
++ }
++ }
++
++ discoveredDevices.append(newDeviceInfo);
++ emit q_ptr->deviceDiscovered(newDeviceInfo);
++ }
++
++ QBluetoothDeviceDiscoveryAgent::DiscoveryMethods QBluetoothDeviceDiscoveryAgent::supportedDiscoveryMethods()
++ {
++ #ifdef Q_OS_MACOS
++ return ClassicMethod | LowEnergyMethod;
++ #else
++ return LowEnergyMethod;
++ #endif // Q_OS_MACOS
++ }
++
++ QT_END_NAMESPACE