qbluetoothservicediscoveryagent_android.cpp

++ // Copyright (C) 2016 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 "qbluetoothservicediscoveryagent_p.h"

++ #include "qbluetoothsocket_android_p.h"

++ #include "android/servicediscoverybroadcastreceiver_p.h"

++ #include "android/localdevicebroadcastreceiver_p.h"

++ #include "android/androidutils_p.h"

++ #include "android/jni_android_p.h"

++

++ #include <QCoreApplication>

++ #include <QtCore/qcoreapplication.h>

++ #include <QtCore/QLoggingCategory>

++ #include <QtCore/QTimer>

++ #include <QtCore/QJniEnvironment>

++ #include <QtBluetooth/QBluetoothHostInfo>

++ #include <QtBluetooth/QBluetoothLocalDevice>

++ #include <QtBluetooth/QBluetoothServiceDiscoveryAgent>

++

++ QT_BEGIN_NAMESPACE

++

++ Q_DECLARE_LOGGING_CATEGORY(QT_BT_ANDROID)

++

++ static constexpr auto uuidFetchTimeLimit = std::chrono::seconds{4};

++

++ QBluetoothServiceDiscoveryAgentPrivate::QBluetoothServiceDiscoveryAgentPrivate(

++         QBluetoothServiceDiscoveryAgent *qp, const QBluetoothAddress &deviceAdapter)

++     : error(QBluetoothServiceDiscoveryAgent::NoError),

++       m_deviceAdapterAddress(deviceAdapter),

++       state(Inactive),

++       mode(QBluetoothServiceDiscoveryAgent::MinimalDiscovery),

++       singleDevice(false),

++       q_ptr(qp)

++

++ {

++     // If a specific adapter address is requested we need to check it matches

++     // the current local adapter. If it does not match we emit

++     // InvalidBluetoothAdapterError when calling start()

++

++     bool createAdapter = true;

++     if (!deviceAdapter.isNull()) {

++         const QList<QBluetoothHostInfo> devices = QBluetoothLocalDevice::allDevices();

++         if (devices.isEmpty()) {

++             createAdapter = false;

++         } else {

++             auto match = [deviceAdapter](const QBluetoothHostInfo& info) {

++                 return info.address() == deviceAdapter;

++             };

++

++             auto result = std::find_if(devices.begin(), devices.end(), match);

++             if (result == devices.end())

++                 createAdapter = false;

++         }

++     }

++

++     /*

++       We assume that the current local adapter has been passed.

++       The logic below must change once there is more than one adapter.

++     */

++

++     if (createAdapter)

++         btAdapter = getDefaultBluetoothAdapter();

++

++     if (!btAdapter.isValid())

++         qCWarning(QT_BT_ANDROID) << "Platform does not support Bluetooth";

++

++     qRegisterMetaType<QList<QBluetoothUuid> >();

++ }

++

++ QBluetoothServiceDiscoveryAgentPrivate::~QBluetoothServiceDiscoveryAgentPrivate()

++ {

++     if (receiver) {

++         receiver->unregisterReceiver();

++         delete receiver;

++     }

++     if (localDeviceReceiver) {

++         localDeviceReceiver->unregisterReceiver();

++         delete localDeviceReceiver;

++     }

++ }

++

++ void QBluetoothServiceDiscoveryAgentPrivate::start(const QBluetoothAddress &address)

++ {

++     Q_Q(QBluetoothServiceDiscoveryAgent);

++

++     if (!ensureAndroidPermission(QBluetoothPermission::Access)) {

++         qCWarning(QT_BT_ANDROID) << "Service discovery start() failed due to missing permissions";

++         error = QBluetoothServiceDiscoveryAgent::MissingPermissionsError;

++         errorString = QBluetoothServiceDiscoveryAgent::tr(

++                 "Failed to start service discovery due to missing permissions.");

++         emit q->errorOccurred(error);

++         _q_serviceDiscoveryFinished();

++         return;

++     }

++

++     if (!btAdapter.isValid()) {

++         if (m_deviceAdapterAddress.isNull()) {

++             error = QBluetoothServiceDiscoveryAgent::UnknownError;

++             errorString = QBluetoothServiceDiscoveryAgent::tr("Platform does not support Bluetooth");

++         } else {

++             // specific adapter was requested which does not match the locally

++             // existing adapter

++             error = QBluetoothServiceDiscoveryAgent::InvalidBluetoothAdapterError;

++             errorString = QBluetoothServiceDiscoveryAgent::tr("Invalid Bluetooth adapter address");

++         }

++

++         //abort any outstanding discoveries

++         discoveredDevices.clear();

++         emit q->errorOccurred(error);

++         _q_serviceDiscoveryFinished();

++

++         return;

++     }

++

++     QJniObject inputString = QJniObject::fromString(address.toString());

++     QJniObject remoteDevice =

++             btAdapter.callMethod<QtJniTypes::BluetoothDevice>("getRemoteDevice",

++                                                               inputString.object<jstring>());

++     if (!remoteDevice.isValid()) {

++

++         //if it was only device then its error -> otherwise go to next device

++         if (singleDevice) {

++             error = QBluetoothServiceDiscoveryAgent::InputOutputError;

++             errorString = QBluetoothServiceDiscoveryAgent::tr("Cannot create Android BluetoothDevice");

++

++             qCWarning(QT_BT_ANDROID) << "Cannot start SDP for" << discoveredDevices.at(0).name()

++                                      << "(" << address.toString() << ")";

++             emit q->errorOccurred(error);

++         }

++         _q_serviceDiscoveryFinished();

++         return;

++     }

++

++

++     if (mode == QBluetoothServiceDiscoveryAgent::MinimalDiscovery) {

++         qCDebug(QT_BT_ANDROID) << "Minimal discovery on (" << discoveredDevices.at(0).name()

++                                << ")" << address.toString() ;

++

++         //Minimal discovery uses BluetoothDevice.getUuids()

++         const QJniArray parcelUuidArray =

++                 remoteDevice.callMethod<QtJniTypes::ParcelUuid[]>("getUuids");

++

++         if (!parcelUuidArray.isValid()) {

++             if (singleDevice) {

++                 error = QBluetoothServiceDiscoveryAgent::InputOutputError;

++                 errorString = QBluetoothServiceDiscoveryAgent::tr("Cannot obtain service uuids");

++                 emit q->errorOccurred(error);

++             }

++             qCWarning(QT_BT_ANDROID) << "Cannot retrieve SDP UUIDs for" << discoveredDevices.at(0).name()

++                                      << "(" << address.toString() << ")";

++             _q_serviceDiscoveryFinished();

++             return;

++         }

++

++         const QList<QBluetoothUuid> results = ServiceDiscoveryBroadcastReceiver::convertParcelableArray(parcelUuidArray);

++         populateDiscoveredServices(discoveredDevices.at(0), results);

++

++         _q_serviceDiscoveryFinished();

++     } else {

++         qCDebug(QT_BT_ANDROID) << "Full discovery on (" << discoveredDevices.at(0).name()

++                                << ")" << address.toString();

++

++         //Full discovery uses BluetoothDevice.fetchUuidsWithSdp()

++         if (!receiver) {

++             receiver = new ServiceDiscoveryBroadcastReceiver();

++             QObject::connect(receiver, &ServiceDiscoveryBroadcastReceiver::uuidFetchFinished,

++                              q, [this](const QBluetoothAddress &address, const QList<QBluetoothUuid>& uuids) {

++                 this->_q_processFetchedUuids(address, uuids);

++             });

++         }

++

++         if (!localDeviceReceiver) {

++             localDeviceReceiver = new LocalDeviceBroadcastReceiver();

++             QObject::connect(localDeviceReceiver, &LocalDeviceBroadcastReceiver::hostModeStateChanged,

++                              q, [this](QBluetoothLocalDevice::HostMode state){

++                 this->_q_hostModeStateChanged(state);

++             });

++         }

++

++         jboolean result = remoteDevice.callMethod<jboolean>("fetchUuidsWithSdp");

++         if (!result) {

++             //kill receiver to limit load of signals

++             receiver->unregisterReceiver();

++             receiver->deleteLater();

++             receiver = nullptr;

++             qCWarning(QT_BT_ANDROID) << "Cannot start dynamic fetch.";

++             _q_serviceDiscoveryFinished();

++         }

++     }

++ }

++

++ void QBluetoothServiceDiscoveryAgentPrivate::stop()

++ {

++     sdpCache.clear();

++     discoveredDevices.clear();

++

++     //kill receiver to limit load of signals

++     if (receiver) {

++         receiver->unregisterReceiver();

++         receiver->deleteLater();

++         receiver = nullptr;

++     }

++

++     Q_Q(QBluetoothServiceDiscoveryAgent);

++     emit q->canceled();

++

++ }

++

++ void QBluetoothServiceDiscoveryAgentPrivate::_q_processFetchedUuids(

++     const QBluetoothAddress &address, const QList<QBluetoothUuid> &uuids)

++ {

++     //don't leave more data through if we are not interested anymore

++     if (discoveredDevices.isEmpty())

++         return;

++

++     //could not find any service for the current address/device -> go to next one

++     if (address.isNull() || uuids.isEmpty()) {

++         if (discoveredDevices.size() == 1) {

++             Q_Q(QBluetoothServiceDiscoveryAgent);

++             QTimer::singleShot(uuidFetchTimeLimit, q, [this]() {

++                 this->_q_fetchUuidsTimeout();

++             }); // will also call _q_serviceDiscoveryFinished()

++         } else {

++             _q_serviceDiscoveryFinished();

++         }

++         return;

++     }

++

++     if (QT_BT_ANDROID().isDebugEnabled()) {

++         qCDebug(QT_BT_ANDROID) << "Found UUID for" << address.toString()

++                                << "\ncount: " << uuids.size();

++

++         QString result;

++         for (const QBluetoothUuid &uuid : uuids)

++             result += uuid.toString() + QLatin1String("**");

++         qCDebug(QT_BT_ANDROID) << result;

++     }

++

++     /* In general there may be up-to two uuid events per device.

++      * We'll wait for the second event to arrive before we process the UUIDs.

++      * We utilize a timeout to catch cases when the second

++      * event doesn't arrive at all.

++      * Generally we assume that the second uuid event carries the most up-to-date

++      * set of uuids and discard the first events results.

++     */

++

++     if (sdpCache.contains(address)) {

++         //second event

++         QPair<QBluetoothDeviceInfo,QList<QBluetoothUuid> > pair = sdpCache.take(address);

++

++         //prefer second uuid set over first

++         populateDiscoveredServices(pair.first, uuids);

++

++         if (discoveredDevices.size() == 1 && sdpCache.isEmpty()) {

++             //last regular uuid data set from OS -> we finish here

++             _q_serviceDiscoveryFinished();

++         }

++     } else {

++         //first event

++         QPair<QBluetoothDeviceInfo,QList<QBluetoothUuid> > pair;

++         pair.first = discoveredDevices.at(0);

++         pair.second = uuids;

++

++         if (pair.first.address() != address)

++             return;

++

++         sdpCache.insert(address, pair);

++

++         //the discovery on the last device cannot immediately finish

++         //we have to grant the timeout delay to allow potential second event to arrive

++         if (discoveredDevices.size() == 1) {

++             Q_Q(QBluetoothServiceDiscoveryAgent);

++             QTimer::singleShot(uuidFetchTimeLimit, q, [this]() {

++                 this->_q_fetchUuidsTimeout();

++             });

++             return;

++         }

++

++         _q_serviceDiscoveryFinished();

++     }

++ }

++

++ void QBluetoothServiceDiscoveryAgentPrivate::populateDiscoveredServices(const QBluetoothDeviceInfo &remoteDevice, const QList<QBluetoothUuid> &uuids)

++ {

++     /* Android doesn't provide decent SDP data. A flat list of uuids is all we get.

++      *

++      * The following approach is chosen:

++      * - If we see an SPP service class and we see

++      *   one or more custom uuids we match them up. Such services will always

++      *   be SPP services. There is the chance that a custom uuid is eronously

++      *   mapped as being an SPP service. In addition, the SPP uuid will be mapped as

++      *   standalone SPP service.

++      * - If we see a custom uuid but no SPP uuid then we return

++      *   BluetoothServiceInfo instance with just a serviceUuid (no service class set)

++      * - If we don't find any custom uuid but the SPP uuid, we return a

++      *   BluetoothServiceInfo instance where classId and serviceUuid() are set to SPP.

++      * - Any other service uuid will stand on its own.

++      * */

++

++     Q_Q(QBluetoothServiceDiscoveryAgent);

++

++     //find SPP and custom uuid

++     bool haveSppClass = false;

++     QVarLengthArray<qsizetype> customUuids;

++

++     for (qsizetype i = 0; i < uuids.size(); ++i) {

++         const QBluetoothUuid uuid = uuids.at(i);

++

++         if (uuid.isNull())

++             continue;

++

++         //check for SPP protocol

++         haveSppClass |= uuid == QBluetoothUuid::ServiceClassUuid::SerialPort;

++

++         //check for custom uuid

++         if (uuid.minimumSize() == 16)

++             customUuids.append(i);

++     }

++

++     auto rfcommProtocolDescriptorList = []() -> QBluetoothServiceInfo::Sequence {

++             QBluetoothServiceInfo::Sequence protocol;

++             protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::ProtocolUuid::Rfcomm))

++                      << QVariant::fromValue(0);

++             return protocol;

++     };

++

++     auto sppProfileDescriptorList = []() -> QBluetoothServiceInfo::Sequence {

++         QBluetoothServiceInfo::Sequence profileSequence;

++         QBluetoothServiceInfo::Sequence classId;

++         classId << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::ServiceClassUuid::SerialPort));

++         classId << QVariant::fromValue(quint16(0x100));

++         profileSequence.append(QVariant::fromValue(classId));

++         return profileSequence;

++     };

++

++     for (qsizetype i = 0; i < uuids.size(); ++i) {

++         const QBluetoothUuid &uuid = uuids.at(i);

++         if (uuid.isNull())

++             continue;

++

++         QBluetoothServiceInfo serviceInfo;

++         serviceInfo.setDevice(remoteDevice);

++

++         QBluetoothServiceInfo::Sequence protocolDescriptorList;

++         {

++             QBluetoothServiceInfo::Sequence protocol;

++             protocol << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::ProtocolUuid::L2cap));

++             protocolDescriptorList.append(QVariant::fromValue(protocol));

++         }

++

++         if (customUuids.contains(i) && haveSppClass) {

++             //we have a custom uuid of service class type SPP

++

++             //set rfcomm protocol

++             protocolDescriptorList.append(QVariant::fromValue(rfcommProtocolDescriptorList()));

++

++             //set SPP profile descriptor list

++             serviceInfo.setAttribute(QBluetoothServiceInfo::BluetoothProfileDescriptorList,

++                                      sppProfileDescriptorList());

++

++             QBluetoothServiceInfo::Sequence classId;

++             //set SPP service class uuid

++             classId << QVariant::fromValue(uuid);

++             classId << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::ServiceClassUuid::SerialPort));

++             serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceClassIds, classId);

++

++             serviceInfo.setServiceName(QBluetoothServiceDiscoveryAgent::tr("Serial Port Profile"));

++             serviceInfo.setServiceUuid(uuid);

++         } else if (uuid == QBluetoothUuid{QBluetoothUuid::ServiceClassUuid::SerialPort}) {

++             //set rfcomm protocol

++             protocolDescriptorList.append(QVariant::fromValue(rfcommProtocolDescriptorList()));

++

++             //set SPP profile descriptor list

++             serviceInfo.setAttribute(QBluetoothServiceInfo::BluetoothProfileDescriptorList,

++                                      sppProfileDescriptorList());

++

++             //also we need to set the custom uuid to the SPP uuid

++             //otherwise QBluetoothSocket::connectToService() would fail due to a missing service uuid

++             serviceInfo.setServiceUuid(uuid);

++         } else if (customUuids.contains(i)) {

++             //custom uuid but no serial port

++             serviceInfo.setServiceUuid(uuid);

++         }

++

++         serviceInfo.setAttribute(QBluetoothServiceInfo::ProtocolDescriptorList, protocolDescriptorList);

++         QBluetoothServiceInfo::Sequence publicBrowse;

++         publicBrowse << QVariant::fromValue(QBluetoothUuid(QBluetoothUuid::ServiceClassUuid::PublicBrowseGroup));

++         serviceInfo.setAttribute(QBluetoothServiceInfo::BrowseGroupList, publicBrowse);

++

++         if (!customUuids.contains(i)) {

++             //if we don't have custom uuid use it as class id as well

++             QBluetoothServiceInfo::Sequence classId;

++             classId << QVariant::fromValue(uuid);

++             serviceInfo.setAttribute(QBluetoothServiceInfo::ServiceClassIds, classId);

++             auto clsId = QBluetoothUuid::ServiceClassUuid(uuid.toUInt16());

++             serviceInfo.setServiceName(QBluetoothUuid::serviceClassToString(clsId));

++         }

++

++         //Check if the service is in the uuidFilter

++         if (!uuidFilter.isEmpty()) {

++             bool match = uuidFilter.contains(serviceInfo.serviceUuid());

++             match |= uuidFilter.contains(QBluetoothSocketPrivateAndroid::reverseUuid(serviceInfo.serviceUuid()));

++             for (const auto &uuid : std::as_const(uuidFilter)) {

++                 match |= serviceInfo.serviceClassUuids().contains(uuid);

++                 match |= serviceInfo.serviceClassUuids().contains(QBluetoothSocketPrivateAndroid::reverseUuid(uuid));

++             }

++

++             if (!match)

++                 continue;

++         }

++

++         //don't include the service if we already discovered it before

++         if (!isDuplicatedService(serviceInfo)) {

++             discoveredServices << serviceInfo;

++             // Use queued connection to allow us finish the service discovery reporting;

++             // the application might call stop() when it has detected the service-of-interest,

++             // which in turn can cause the use of already released resources

++             QMetaObject::invokeMethod(q, "serviceDiscovered", Qt::QueuedConnection,

++                                       Q_ARG(QBluetoothServiceInfo, serviceInfo));

++         }

++     }

++ }

++

++ void QBluetoothServiceDiscoveryAgentPrivate::_q_fetchUuidsTimeout()

++ {

++     // In practice if device list is empty, discovery has been stopped or bluetooth is offline

++     if (discoveredDevices.isEmpty())

++         return;

++

++     // Process remaining services in the cache (these didn't get a second UUID event)

++     if (!sdpCache.isEmpty()) {

++         QPair<QBluetoothDeviceInfo,QList<QBluetoothUuid> > pair;

++         const QList<QBluetoothAddress> keys = sdpCache.keys();

++         for (const QBluetoothAddress &key : keys) {

++             pair = sdpCache.take(key);

++             populateDiscoveredServices(pair.first, pair.second);

++         }

++     }

++

++     Q_ASSERT(sdpCache.isEmpty());

++

++     //kill receiver to limit load of signals

++     if (receiver) {

++         receiver->unregisterReceiver();

++         receiver->deleteLater();

++         receiver = nullptr;

++     }

++     _q_serviceDiscoveryFinished();

++ }

++

++ void QBluetoothServiceDiscoveryAgentPrivate::_q_hostModeStateChanged(QBluetoothLocalDevice::HostMode state)

++ {

++     if (discoveryState() == QBluetoothServiceDiscoveryAgentPrivate::ServiceDiscovery &&

++             state == QBluetoothLocalDevice::HostPoweredOff ) {

++

++         discoveredDevices.clear();

++         sdpCache.clear();

++         error = QBluetoothServiceDiscoveryAgent::PoweredOffError;

++         errorString = QBluetoothServiceDiscoveryAgent::tr("Device is powered off");

++

++         //kill receiver to limit load of signals

++         if (receiver) {

++             receiver->unregisterReceiver();

++             receiver->deleteLater();

++             receiver = nullptr;

++         }

++

++         Q_Q(QBluetoothServiceDiscoveryAgent);

++         emit q->errorOccurred(error);

++         _q_serviceDiscoveryFinished();

++     }

++ }

++

++ QT_END_NAMESPACE

Revision control