qbluetoothdevicediscoveryagent_android.cpp

++ // Copyright (C) 2016 Lauri Laanmets (Proekspert AS) <lauri.laanmets@eesti.ee>

++ // 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 "android/devicediscoverybroadcastreceiver_p.h"

++ #include "android/androidutils_p.h"

++ #include "android/jni_android_p.h"

++ #include "qbluetoothdevicediscoveryagent_p.h"

++ #include <QCoreApplication>

++ #include <QtCore/QLoggingCategory>

++ #include <QtCore/qpermissions.h>

++ #include <QtBluetooth/QBluetoothAddress>

++ #include <QtBluetooth/QBluetoothDeviceInfo>

++ #include <QtCore/QJniEnvironment>

++ #include <QtCore/private/qandroidextras_p.h>

++

++ QT_BEGIN_NAMESPACE

++

++ Q_DECLARE_LOGGING_CATEGORY(QT_BT_ANDROID)

++

++ enum {

++     NoScanActive = 0,

++     SDPScanActive = 1,

++     BtleScanActive = 2

++ };

++

++ static constexpr auto deviceDiscoveryStartTimeLimit = std::chrono::seconds{5};

++ static constexpr short deviceDiscoveryStartMaxAttempts = 6;

++

++ QBluetoothDeviceDiscoveryAgentPrivate::QBluetoothDeviceDiscoveryAgentPrivate(

++     const QBluetoothAddress &deviceAdapter, QBluetoothDeviceDiscoveryAgent *parent) :

++     adapterAddress(deviceAdapter),

++     m_active(NoScanActive),

++     deviceDiscoveryStartAttemptsLeft(deviceDiscoveryStartMaxAttempts),

++     q_ptr(parent)

++ {

++     adapter = getDefaultBluetoothAdapter();

++

++     if (!adapter.isValid())

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

++ }

++

++ QBluetoothDeviceDiscoveryAgentPrivate::~QBluetoothDeviceDiscoveryAgentPrivate()

++ {

++     if (m_active != NoScanActive)

++         stop();

++

++     if (leScanner.isValid())

++         leScanner.setField("qtObject", reinterpret_cast<jlong>(nullptr));

++

++     if (receiver) {

++         receiver->unregisterReceiver();

++         delete receiver;

++     }

++ }

++

++ bool QBluetoothDeviceDiscoveryAgentPrivate::isActive() const

++ {

++     if (pendingStart)

++         return true;

++     if (pendingCancel)

++         return false;

++     return m_active != NoScanActive;

++ }

++

++ QBluetoothDeviceDiscoveryAgent::DiscoveryMethods QBluetoothDeviceDiscoveryAgent::supportedDiscoveryMethods()

++ {

++     return (LowEnergyMethod | ClassicMethod);

++ }

++

++ void QBluetoothDeviceDiscoveryAgentPrivate::classicDiscoveryStartFail()

++ {

++     Q_Q(QBluetoothDeviceDiscoveryAgent);

++     lastError = QBluetoothDeviceDiscoveryAgent::InputOutputError;

++     errorString = QBluetoothDeviceDiscoveryAgent::tr("Classic Discovery cannot be started");

++     emit q->errorOccurred(lastError);

++ }

++

++ // Sets & emits an error and returns true if bluetooth is off

++ bool QBluetoothDeviceDiscoveryAgentPrivate::setErrorIfPowerOff()

++ {

++     Q_Q(QBluetoothDeviceDiscoveryAgent);

++

++     const int state = adapter.callMethod<jint>("getState");

++     if (state != 12) {  // BluetoothAdapter.STATE_ON

++         lastError = QBluetoothDeviceDiscoveryAgent::PoweredOffError;

++         m_active = NoScanActive;

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

++         emit q->errorOccurred(lastError);

++         return true;

++     }

++     return false;

++ }

++

++ /*

++ The Classic/LE discovery method precedence is handled as follows:

++

++ If only classic method is set => only classic method is used

++ If only LE method is set => only LE method is used

++ If both classic and LE methods are set, start classic scan first

++     If classic scan fails to start, start LE scan immediately in the start function

++     Otherwise start LE scan when classic scan completes

++ */

++

++ void QBluetoothDeviceDiscoveryAgentPrivate::start(QBluetoothDeviceDiscoveryAgent::DiscoveryMethods methods)

++ {

++     requestedMethods = methods;

++

++     if (pendingCancel) {

++         pendingStart = true;

++         return;

++     }

++

++     Q_Q(QBluetoothDeviceDiscoveryAgent);

++

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

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

++         lastError = QBluetoothDeviceDiscoveryAgent::InputOutputError;

++         errorString = QBluetoothDeviceDiscoveryAgent::tr("Device does not support Bluetooth");

++         emit q->errorOccurred(lastError);

++         return;

++     }

++

++     if (!adapterAddress.isNull()

++         && adapter.callMethod<jstring>("getAddress").toString()

++         != adapterAddress.toString()) {

++         qCWarning(QT_BT_ANDROID) << "Incorrect local adapter passed.";

++         lastError = QBluetoothDeviceDiscoveryAgent::InvalidBluetoothAdapterError;

++         errorString = QBluetoothDeviceDiscoveryAgent::tr("Passed address is not a local device.");

++         emit q->errorOccurred(lastError);

++         return;

++     }

++

++     if (setErrorIfPowerOff())

++         return;

++

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

++         qCWarning(QT_BT_ANDROID)

++                 << "Search not possible due to missing QBluetoothPermission::Access permission";

++         errorString = QBluetoothDeviceDiscoveryAgent::tr(

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

++         lastError = QBluetoothDeviceDiscoveryAgent::MissingPermissionsError;

++         emit q->errorOccurred(lastError);

++         return;

++     }

++     qCDebug(QT_BT_ANDROID) << "QBluetoothPermission::Access permission available";

++

++     const bool scanNeedsLocation = (bool)QtJniTypes::QtBtUtility::callStaticMethod<jboolean>(

++             "bluetoothScanRequiresLocation", QNativeInterface::QAndroidApplication::context());

++

++     qCDebug(QT_BT_ANDROID) << "Is location service and location permission required for scan:"

++                            << scanNeedsLocation;

++

++     if (scanNeedsLocation) {

++         // Double check we have location permission. With API-level < 31 it is already

++         // guaranteed by the ensureAndroidPermission() above, but with API-level 31+ it is

++         // required additionally if 'neverForLocation' assertion isn't set.

++         QLocationPermission locationPermission;

++         locationPermission.setAccuracy(QLocationPermission::Accuracy::Precise);

++

++         if (qApp->checkPermission(locationPermission) != Qt::PermissionStatus::Granted) {

++             qCWarning(QT_BT_ANDROID) << "Search not possible due to missing location permissions";

++             lastError = QBluetoothDeviceDiscoveryAgent::LocationServiceTurnedOffError;

++             errorString = QBluetoothDeviceDiscoveryAgent::tr("Location permission not granted. Search is not possible.");

++             emit q->errorOccurred(lastError);

++             return;

++         }

++

++         qCDebug(QT_BT_ANDROID) << "Location permission granted";

++

++         // Double check Location service is turned on

++         bool locationTurnedOn = true; // backwards compatible behavior to previous Qt versions

++         const  QJniObject locString = QJniObject::getStaticObjectField(

++             "android/content/Context", "LOCATION_SERVICE", "Ljava/lang/String;");

++

++         const QJniObject locService =

++             QJniObject(QNativeInterface::QAndroidApplication::context()).callMethod<jobject>(

++                 "getSystemService",

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

++

++         if (locService.isValid()) {

++             if (QNativeInterface::QAndroidApplication::sdkVersion() >= 28) {

++                 locationTurnedOn = bool(locService.callMethod<jboolean>("isLocationEnabled"));

++             } else {

++                 // check whether there is any enabled provider

++                 QJniObject listOfEnabledProviders =

++                     locService.callMethod<QtJniTypes::List>("getProviders", true);

++

++                 if (listOfEnabledProviders.isValid()) {

++                     int size = listOfEnabledProviders.callMethod<jint>("size");

++                     locationTurnedOn = size > 0;

++                     qCDebug(QT_BT_ANDROID) << size << "enabled location providers detected.";

++                 }

++             }

++         }

++

++         if (!locationTurnedOn) {

++             qCWarning(QT_BT_ANDROID) << "Search not possible due to turned off Location service";

++             lastError = QBluetoothDeviceDiscoveryAgent::LocationServiceTurnedOffError;

++             errorString = QBluetoothDeviceDiscoveryAgent::tr("Location service turned off. Search is not possible.");

++             emit q->errorOccurred(lastError);

++             return;

++         }

++

++         qCDebug(QT_BT_ANDROID) << "Location turned on";

++     }

++

++     // install Java BroadcastReceiver

++     if (!receiver) {

++         // SDP based device discovery

++         receiver = new DeviceDiscoveryBroadcastReceiver();

++         qRegisterMetaType<QBluetoothDeviceInfo>();

++         QObject::connect(receiver, SIGNAL(deviceDiscovered(QBluetoothDeviceInfo,bool)),

++                          this, SLOT(processDiscoveredDevices(QBluetoothDeviceInfo,bool)));

++         QObject::connect(receiver, SIGNAL(finished()), this, SLOT(processSdpDiscoveryFinished()));

++     }

++

++     lastError = QBluetoothDeviceDiscoveryAgent::NoError;

++     errorString.clear();

++     discoveredDevices.clear();

++

++     // by arbitrary definition we run classic search first

++     if (requestedMethods & QBluetoothDeviceDiscoveryAgent::ClassicMethod) {

++         const bool success = adapter.callMethod<jboolean>("startDiscovery");

++         if (!success) {

++             qCDebug(QT_BT_ANDROID) << "Classic Discovery cannot be started";

++             // Check if only classic discovery requested -> error out and return.

++             // Otherwise since LE was also requested => don't return but allow the

++             // function to continue to LE scanning

++             if (requestedMethods == QBluetoothDeviceDiscoveryAgent::ClassicMethod) {

++                 classicDiscoveryStartFail();

++                 return;

++             }

++         } else {

++             m_active = SDPScanActive;

++             if (!deviceDiscoveryStartTimeout) {

++                 // In some bluetooth environments device discovery does not start properly

++                 // if it is done shortly after (up to 20 seconds) a full service discovery.

++                 // In that case we never get DISOVERY_STARTED action and device discovery never

++                 // finishes. Here we use a small timeout to guard it; if we don't get the

++                 // 'started' action in time, we restart the query. In the normal case the action

++                 // is received in < 1 second. See QTBUG-101066

++                 deviceDiscoveryStartTimeout = new QTimer(this);

++                 deviceDiscoveryStartTimeout->setInterval(deviceDiscoveryStartTimeLimit);

++                 deviceDiscoveryStartTimeout->setSingleShot(true);

++                 QObject::connect(receiver, &DeviceDiscoveryBroadcastReceiver::discoveryStarted,

++                                  deviceDiscoveryStartTimeout, &QTimer::stop);

++                 QObject::connect(deviceDiscoveryStartTimeout, &QTimer::timeout, this, [this]() {

++                     deviceDiscoveryStartAttemptsLeft -= 1;

++                     qCWarning(QT_BT_ANDROID) << "Discovery start not received, attempts left:"

++                                              <<  deviceDiscoveryStartAttemptsLeft;

++                     // Check that bluetooth is not switched off

++                     if (setErrorIfPowerOff())

++                         return;

++                     // If this was the last retry attempt, cancel the discovery just in case

++                     // as a good cleanup practice

++                     if (deviceDiscoveryStartAttemptsLeft <= 0) {

++                         qCWarning(QT_BT_ANDROID) << "Classic device discovery failed to start";

++                         (void)adapter.callMethod<jboolean>("cancelDiscovery");

++                     }

++                     // Restart the discovery and retry timer.

++                     // The logic below is similar as in the start()

++                     if (deviceDiscoveryStartAttemptsLeft > 0 &&

++                             adapter.callMethod<jboolean>("startDiscovery"))

++                         deviceDiscoveryStartTimeout->start();

++                     else if (requestedMethods == QBluetoothDeviceDiscoveryAgent::ClassicMethod)

++                         classicDiscoveryStartFail(); // No LE scan requested, scan is done

++                     else

++                         startLowEnergyScan(); // Continue to LE scan

++                 });

++             }

++             deviceDiscoveryStartAttemptsLeft = deviceDiscoveryStartMaxAttempts;

++             deviceDiscoveryStartTimeout->start();

++

++             qCDebug(QT_BT_ANDROID)

++                 << "QBluetoothDeviceDiscoveryAgentPrivate::start() - Classic search successfully started.";

++             return;

++         }

++     }

++

++     if (requestedMethods & QBluetoothDeviceDiscoveryAgent::LowEnergyMethod) {

++         // LE search only requested or classic discovery failed but lets try LE scan anyway

++         startLowEnergyScan();

++     }

++ }

++

++ void QBluetoothDeviceDiscoveryAgentPrivate::stop()

++ {

++     Q_Q(QBluetoothDeviceDiscoveryAgent);

++

++     pendingStart = false;

++

++     if (deviceDiscoveryStartTimeout)

++         deviceDiscoveryStartTimeout->stop();

++

++     if (m_active == NoScanActive)

++         return;

++

++     if (m_active == SDPScanActive) {

++         if (pendingCancel) {

++             // If we had both a pending cancel and a pending start,

++             // we now have only a pending cancel.

++             // The pending start was canceled above.

++             return;

++         }

++

++         pendingCancel = true;

++         bool success = adapter.callMethod<jboolean>("cancelDiscovery");

++         if (!success) {

++             lastError = QBluetoothDeviceDiscoveryAgent::InputOutputError;

++             errorString = QBluetoothDeviceDiscoveryAgent::tr("Discovery cannot be stopped");

++             emit q->errorOccurred(lastError);

++             return;

++         }

++     } else if (m_active == BtleScanActive) {

++         if (pendingCancel)

++             return;

++         pendingCancel = true;

++         if (leScanTimeout->isActive())

++             leScanTimeout->stop();

++         stopLowEnergyScan();

++     }

++ }

++

++ void QBluetoothDeviceDiscoveryAgentPrivate::processSdpDiscoveryFinished()

++ {

++     // We need to guard because Android sends two DISCOVERY_FINISHED when cancelling

++     // Also if we have two active agents both receive the same signal.

++     // If this one is not active ignore the device information

++     if (m_active != SDPScanActive)

++         return;

++

++     Q_Q(QBluetoothDeviceDiscoveryAgent);

++

++     if (pendingCancel && !pendingStart) {

++         m_active = NoScanActive;

++         pendingCancel = false;

++         emit q->canceled();

++     } else if (pendingStart) {

++         pendingStart = pendingCancel = false;

++         start(requestedMethods);

++     } else {

++         // check that it didn't finish due to turned off Bluetooth Device

++         if (setErrorIfPowerOff())

++             return;

++         // Since no BTLE scan requested and classic scan is done => finished()

++         if (!(requestedMethods & QBluetoothDeviceDiscoveryAgent::LowEnergyMethod)) {

++             m_active = NoScanActive;

++             emit q->finished();

++             return;

++         }

++

++         startLowEnergyScan();

++     }

++ }

++

++ void QBluetoothDeviceDiscoveryAgentPrivate::processDiscoveredDevices(

++     const QBluetoothDeviceInfo &info, bool isLeResult)

++ {

++     // If we have two active agents both receive the same signal.

++     // If this one is not active ignore the device information

++     if (m_active != SDPScanActive && !isLeResult)

++         return;

++     if (m_active != BtleScanActive && isLeResult)

++         return;

++

++     Q_Q(QBluetoothDeviceDiscoveryAgent);

++

++     // Android Classic scan and LE scan can find the same device under different names

++     // The classic name finds the SDP based device name, the LE scan finds the name in

++     // the advertisement package.

++     // If address is same but name different then we keep both entries.

++

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

++         if (discoveredDevices[i].address() == info.address()) {

++             QBluetoothDeviceInfo::Fields updatedFields = QBluetoothDeviceInfo::Field::None;

++             if (discoveredDevices[i].rssi() != info.rssi()) {

++                 qCDebug(QT_BT_ANDROID) << "Updating RSSI for" << info.address()

++                                        << info.rssi();

++                 discoveredDevices[i].setRssi(info.rssi());

++                 updatedFields.setFlag(QBluetoothDeviceInfo::Field::RSSI);

++             }

++             if (discoveredDevices[i].manufacturerData() != info.manufacturerData()) {

++                 qCDebug(QT_BT_ANDROID) << "Updating manufacturer data for" << info.address();

++                 const QList<quint16> keys = info.manufacturerIds();

++                 for (auto key: keys)

++                     discoveredDevices[i].setManufacturerData(key, info.manufacturerData(key));

++                 updatedFields.setFlag(QBluetoothDeviceInfo::Field::ManufacturerData);

++             }

++             if (discoveredDevices[i].serviceData() != info.serviceData()) {

++                 qCDebug(QT_BT_ANDROID) << "Updating service data for" << info.address();

++                 const QList<QBluetoothUuid> keys = info.serviceIds();

++                 for (auto key : keys)

++                     discoveredDevices[i].setServiceData(key, info.serviceData(key));

++                 updatedFields.setFlag(QBluetoothDeviceInfo::Field::ServiceData);

++             }

++

++             if (lowEnergySearchTimeout > 0) {

++                 if (discoveredDevices[i] != info) {

++                     if (discoveredDevices.at(i).name() == info.name()) {

++                         qCDebug(QT_BT_ANDROID) << "Almost Duplicate " << info.address()

++                                                << info.name() << "- replacing in place";

++                         discoveredDevices.replace(i, info);

++                         emit q->deviceDiscovered(info);

++                     }

++                 } else {

++                     if (!updatedFields.testFlag(QBluetoothDeviceInfo::Field::None))

++                         emit q->deviceUpdated(discoveredDevices[i], updatedFields);

++                 }

++

++                 return;

++             }

++

++             discoveredDevices.replace(i, info);

++             emit q->deviceDiscovered(info);

++

++             if (!updatedFields.testFlag(QBluetoothDeviceInfo::Field::None))

++                 emit q->deviceUpdated(discoveredDevices[i], updatedFields);

++

++             return;

++         }

++     }

++

++     discoveredDevices.append(info);

++     qCDebug(QT_BT_ANDROID) << "Device found: " << info.name() << info.address().toString()

++                            << "isLeScanResult:" << isLeResult

++                            << "Manufacturer data size:" << info.manufacturerData().size();

++     emit q->deviceDiscovered(info);

++ }

++

++ void QBluetoothDeviceDiscoveryAgentPrivate::startLowEnergyScan()

++ {

++     Q_Q(QBluetoothDeviceDiscoveryAgent);

++

++     m_active = BtleScanActive;

++     ++leScanEpoch;

++

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

++         leScanner = QJniObject::construct<QtJniTypes::QtBtLECentral>(

++                     QNativeInterface::QAndroidApplication::context());

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

++             qCWarning(QT_BT_ANDROID) << "Cannot load BTLE device scan class";

++             m_active = NoScanActive;

++             emit q->finished();

++             return;

++         }

++

++         leScanner.setField("qtObject", reinterpret_cast<jlong>(receiver));

++     }

++

++     jboolean result = leScanner.callMethod<jboolean>("scanForLeDevice", true);

++     if (!result) {

++         qCWarning(QT_BT_ANDROID) << "Cannot start BTLE device scanner";

++         m_active = NoScanActive;

++         emit q->finished();

++         return;

++     }

++

++     // wait interval and sum up what was found

++     if (!leScanTimeout) {

++         leScanTimeout = new QTimer(this);

++         leScanTimeout->setSingleShot(true);

++         connect(leScanTimeout, &QTimer::timeout,

++                 this, &QBluetoothDeviceDiscoveryAgentPrivate::stopLowEnergyScan);

++     }

++

++     if (lowEnergySearchTimeout > 0) { // otherwise no timeout and stop() required

++         leScanTimeout->setInterval(lowEnergySearchTimeout);

++         leScanTimeout->start();

++     }

++

++     qCDebug(QT_BT_ANDROID)

++         << "QBluetoothDeviceDiscoveryAgentPrivate::start() - Low Energy search successfully started.";

++ }

++

++ void QBluetoothDeviceDiscoveryAgentPrivate::processLeDiscoveryFinished(int epoch)

++ {

++     // Drop stale or duplicate invocations.

++     if (epoch != leScanEpoch || m_active != BtleScanActive)

++         return;

++

++     m_active = NoScanActive;

++

++     // Same three-way branch as processSdpDiscoveryFinished().

++     Q_Q(QBluetoothDeviceDiscoveryAgent);

++     if (pendingCancel && !pendingStart) {

++         pendingCancel = false;

++         emit q->canceled();

++     } else if (pendingStart) {

++         pendingStart = pendingCancel = false;

++         start(requestedMethods);

++     } else {

++         // timeout -> regular stop

++         emit q->finished();

++     }

++ }

++

++ void QBluetoothDeviceDiscoveryAgentPrivate::stopLowEnergyScan()

++ {

++     jboolean result = leScanner.callMethod<jboolean>("scanForLeDevice", false);

++     if (!result)

++         qCWarning(QT_BT_ANDROID) << "Cannot stop BTLE device scanner";

++

++     // Defer so a follow-up start() can set pendingStart; the captured epoch

++     // skips this handler if a fresh scan starts first.

++     QMetaObject::invokeMethod(this,

++             [this, epoch = leScanEpoch]() { processLeDiscoveryFinished(epoch); },

++             Qt::QueuedConnection);

++ }

++ QT_END_NAMESPACE

Revision control