devicediscoverybroadcastreceiver.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

// Qt-Security score:critical reason:data-parser

#include "android/devicediscoverybroadcastreceiver_p.h"

#include <QCoreApplication>

#include <QtCore/QtEndian>

#include <QtCore/QLoggingCategory>

#include <QtBluetooth/QBluetoothAddress>

#include <QtBluetooth/QBluetoothDeviceInfo>

#include <QtBluetooth/QBluetoothUuid>

#include "android/jni_android_p.h"

#include <QtCore/QHash>

#include <QtCore/qbitarray.h>

#include <algorithm>

QT_BEGIN_NAMESPACE

Q_DECLARE_LOGGING_CATEGORY(QT_BT_ANDROID)

typedef QHash<jint, QBluetoothDeviceInfo::CoreConfigurations> JCachedBtTypes;

Q_GLOBAL_STATIC(JCachedBtTypes, cachedBtTypes)

typedef QHash<jint, QBluetoothDeviceInfo::MajorDeviceClass> JCachedMajorTypes;

Q_GLOBAL_STATIC(JCachedMajorTypes, cachedMajorTypes)

typedef QHash<jint, quint8> JCachedMinorTypes;

Q_GLOBAL_STATIC(JCachedMinorTypes, cachedMinorTypes)

static QBitArray initializeMinorCaches()

    const qsizetype numberOfMajorDeviceClasses = 11; // count QBluetoothDeviceInfo::MajorDeviceClass values

    // switch below used to ensure that we notice additions to MajorDeviceClass enum

    const QBluetoothDeviceInfo::MajorDeviceClass classes = QBluetoothDeviceInfo::ComputerDevice;

    switch (classes) {

    case QBluetoothDeviceInfo::MiscellaneousDevice:

    case QBluetoothDeviceInfo::ComputerDevice:

    case QBluetoothDeviceInfo::PhoneDevice:

    case QBluetoothDeviceInfo::NetworkDevice:

    case QBluetoothDeviceInfo::AudioVideoDevice:

    case QBluetoothDeviceInfo::PeripheralDevice:

    case QBluetoothDeviceInfo::ImagingDevice:

    case QBluetoothDeviceInfo::WearableDevice:

    case QBluetoothDeviceInfo::ToyDevice:

    case QBluetoothDeviceInfo::HealthDevice:

    case QBluetoothDeviceInfo::UncategorizedDevice:

        break;

    default:

        qCWarning(QT_BT_ANDROID) << "Unknown category of major device class:" << classes;

    return QBitArray(numberOfMajorDeviceClasses, false);

Q_GLOBAL_STATIC_WITH_ARGS(QBitArray, initializedCacheTracker, (initializeMinorCaches()))

// class names

static const char javaBluetoothDeviceClassName[] = "android/bluetooth/BluetoothDevice";

static const char javaBluetoothClassDeviceMajorClassName[] = "android/bluetooth/BluetoothClass$Device$Major";

static const char javaBluetoothClassDeviceClassName[] = "android/bluetooth/BluetoothClass$Device";

// field names device type (LE vs classic)

static const char javaDeviceTypeClassic[] = "DEVICE_TYPE_CLASSIC";

static const char javaDeviceTypeDual[] = "DEVICE_TYPE_DUAL";

static const char javaDeviceTypeLE[] = "DEVICE_TYPE_LE";

static const char javaDeviceTypeUnknown[] = "DEVICE_TYPE_UNKNOWN";

struct MajorClassJavaToQtMapping

    const char javaFieldName[14];

    QBluetoothDeviceInfo::MajorDeviceClass qtMajor : 16;

};

static_assert(sizeof(MajorClassJavaToQtMapping) == 16);

static constexpr MajorClassJavaToQtMapping majorMappings[] = {

    { "AUDIO_VIDEO", QBluetoothDeviceInfo::AudioVideoDevice },

    { "COMPUTER", QBluetoothDeviceInfo::ComputerDevice },

    { "HEALTH", QBluetoothDeviceInfo::HealthDevice },

    { "IMAGING", QBluetoothDeviceInfo::ImagingDevice },

    { "MISC", QBluetoothDeviceInfo::MiscellaneousDevice },

    { "NETWORKING", QBluetoothDeviceInfo::NetworkDevice },

    { "PERIPHERAL", QBluetoothDeviceInfo::PeripheralDevice },

    { "PHONE", QBluetoothDeviceInfo::PhoneDevice },

    { "TOY", QBluetoothDeviceInfo::ToyDevice },

    { "UNCATEGORIZED", QBluetoothDeviceInfo::UncategorizedDevice },

    { "WEARABLE", QBluetoothDeviceInfo::WearableDevice },

};

// QBluetoothDeviceInfo::MajorDeviceClass value plus 1 matches index

// UncategorizedDevice shifts to index 0

static constexpr quint8 minorIndexSizes[] = {

  64,  // QBluetoothDevice::UncategorizedDevice

  61,  // QBluetoothDevice::MiscellaneousDevice

  18,  // QBluetoothDevice::ComputerDevice

  35,  // QBluetoothDevice::PhoneDevice

  62,  // QBluetoothDevice::NetworkDevice

  0,  // QBluetoothDevice::AudioVideoDevice

  56,  // QBluetoothDevice::PeripheralDevice

  63,  // QBluetoothDevice::ImagingDEvice

  49,  // QBluetoothDevice::WearableDevice

  42,  // QBluetoothDevice::ToyDevice

  26,  // QBluetoothDevice::HealthDevice

};

struct MinorClassJavaToQtMapping

    char const * javaFieldName;

    quint8 qtMinor;

};

static const MinorClassJavaToQtMapping minorMappings[] = {

    // QBluetoothDevice::AudioVideoDevice -> 17 entries

    { "AUDIO_VIDEO_CAMCORDER", QBluetoothDeviceInfo::Camcorder }, //index 0

    { "AUDIO_VIDEO_CAR_AUDIO", QBluetoothDeviceInfo::CarAudio },

    { "AUDIO_VIDEO_HANDSFREE", QBluetoothDeviceInfo::HandsFreeDevice },

    { "AUDIO_VIDEO_HEADPHONES", QBluetoothDeviceInfo::Headphones },

    { "AUDIO_VIDEO_HIFI_AUDIO", QBluetoothDeviceInfo::HiFiAudioDevice },

    { "AUDIO_VIDEO_LOUDSPEAKER", QBluetoothDeviceInfo::Loudspeaker },

    { "AUDIO_VIDEO_MICROPHONE", QBluetoothDeviceInfo::Microphone },

    { "AUDIO_VIDEO_PORTABLE_AUDIO", QBluetoothDeviceInfo::PortableAudioDevice },

    { "AUDIO_VIDEO_SET_TOP_BOX", QBluetoothDeviceInfo::SetTopBox },

    { "AUDIO_VIDEO_UNCATEGORIZED", QBluetoothDeviceInfo::UncategorizedAudioVideoDevice },

    { "AUDIO_VIDEO_VCR", QBluetoothDeviceInfo::Vcr },

    { "AUDIO_VIDEO_VIDEO_CAMERA", QBluetoothDeviceInfo::VideoCamera },

    { "AUDIO_VIDEO_VIDEO_CONFERENCING", QBluetoothDeviceInfo::VideoConferencing },

    { "AUDIO_VIDEO_VIDEO_DISPLAY_AND_LOUDSPEAKER", QBluetoothDeviceInfo::VideoDisplayAndLoudspeaker },

    { "AUDIO_VIDEO_VIDEO_GAMING_TOY", QBluetoothDeviceInfo::GamingDevice },

    { "AUDIO_VIDEO_VIDEO_MONITOR", QBluetoothDeviceInfo::VideoMonitor },

    { "AUDIO_VIDEO_WEARABLE_HEADSET", QBluetoothDeviceInfo::WearableHeadsetDevice },

    { nullptr, 0 }, // separator

    // QBluetoothDevice::ComputerDevice -> 7 entries

    { "COMPUTER_UNCATEGORIZED", QBluetoothDeviceInfo::UncategorizedComputer }, // index 18

    { "COMPUTER_DESKTOP", QBluetoothDeviceInfo::DesktopComputer },

    { "COMPUTER_HANDHELD_PC_PDA", QBluetoothDeviceInfo::HandheldComputer },

    { "COMPUTER_LAPTOP", QBluetoothDeviceInfo::LaptopComputer },

    { "COMPUTER_PALM_SIZE_PC_PDA", QBluetoothDeviceInfo::HandheldClamShellComputer },

    { "COMPUTER_SERVER", QBluetoothDeviceInfo::ServerComputer },

    { "COMPUTER_WEARABLE", QBluetoothDeviceInfo::WearableComputer },

    { nullptr, 0 },  // separator

    // QBluetoothDevice::HealthDevice -> 8 entries

    { "HEALTH_BLOOD_PRESSURE", QBluetoothDeviceInfo::HealthBloodPressureMonitor }, // index 26

    { "HEALTH_DATA_DISPLAY", QBluetoothDeviceInfo::HealthDataDisplay },

    { "HEALTH_GLUCOSE", QBluetoothDeviceInfo::HealthGlucoseMeter },

    { "HEALTH_PULSE_OXIMETER", QBluetoothDeviceInfo::HealthPulseOximeter },

    { "HEALTH_PULSE_RATE", QBluetoothDeviceInfo::HealthStepCounter },

    { "HEALTH_THERMOMETER", QBluetoothDeviceInfo::HealthThermometer },

    { "HEALTH_UNCATEGORIZED", QBluetoothDeviceInfo::UncategorizedHealthDevice },

    { "HEALTH_WEIGHING", QBluetoothDeviceInfo::HealthWeightScale },

    { nullptr, 0 }, // separator

    // QBluetoothDevice::PhoneDevice -> 6 entries

    { "PHONE_CELLULAR", QBluetoothDeviceInfo::CellularPhone }, // index 35

    { "PHONE_CORDLESS", QBluetoothDeviceInfo::CordlessPhone },

    { "PHONE_ISDN", QBluetoothDeviceInfo::CommonIsdnAccessPhone },

    { "PHONE_MODEM_OR_GATEWAY", QBluetoothDeviceInfo::WiredModemOrVoiceGatewayPhone },

    { "PHONE_SMART", QBluetoothDeviceInfo::SmartPhone },

    { "PHONE_UNCATEGORIZED", QBluetoothDeviceInfo::UncategorizedPhone },

    { nullptr, 0 }, // separator

    // QBluetoothDevice::ToyDevice -> 6 entries

    { "TOY_CONTROLLER", QBluetoothDeviceInfo::ToyController }, // index 42

    { "TOY_DOLL_ACTION_FIGURE", QBluetoothDeviceInfo::ToyDoll },

    { "TOY_GAME", QBluetoothDeviceInfo::ToyGame },

    { "TOY_ROBOT", QBluetoothDeviceInfo::ToyRobot },

    { "TOY_UNCATEGORIZED", QBluetoothDeviceInfo::UncategorizedToy },

    { "TOY_VEHICLE", QBluetoothDeviceInfo::ToyVehicle },

    { nullptr, 0 }, // separator

    // QBluetoothDevice::WearableDevice -> 6 entries

    { "WEARABLE_GLASSES", QBluetoothDeviceInfo::WearableGlasses }, // index 49

    { "WEARABLE_HELMET", QBluetoothDeviceInfo::WearableHelmet },

    { "WEARABLE_JACKET", QBluetoothDeviceInfo::WearableJacket },

    { "WEARABLE_PAGER", QBluetoothDeviceInfo::WearablePager },

    { "WEARABLE_UNCATEGORIZED", QBluetoothDeviceInfo::UncategorizedWearableDevice },

    { "WEARABLE_WRIST_WATCH", QBluetoothDeviceInfo::WearableWristWatch },

    { nullptr, 0 }, // separator

    // QBluetoothDevice::PeripheralDevice -> 3 entries

    // For some reason these are not mentioned in Android docs but still exist

    { "PERIPHERAL_NON_KEYBOARD_NON_POINTING", QBluetoothDeviceInfo::UncategorizedPeripheral }, // index 56

    { "PERIPHERAL_KEYBOARD", QBluetoothDeviceInfo::KeyboardPeripheral },

    { "PERIPHERAL_POINTING", QBluetoothDeviceInfo::PointingDevicePeripheral },

    { "PERIPHERAL_KEYBOARD_POINTING", QBluetoothDeviceInfo::KeyboardWithPointingDevicePeripheral },

    { nullptr, 0 }, // separator

    // the following entries do not exist on Android

    // we map them to the unknown minor version case

    // QBluetoothDevice::Miscellaneous

    { nullptr, 0 }, // index 61 & separator

    // QBluetoothDevice::NetworkDevice

    { nullptr, 0 }, // index 62 & separator

    // QBluetoothDevice::ImagingDevice

    { nullptr, 0 }, // index 63 & separator

    // QBluetoothDevice::UncategorizedDevice

    { nullptr, 0 }, // index 64 & separator

};

/*

    Advertising Data Type (AD type) for LE scan records, as defined in

    https://www.bluetooth.com/specifications/assigned-numbers/generic-access-profile

*/

enum ADType {

    ADType16BitUuidIncomplete = 0x02,

    ADType16BitUuidComplete = 0x03,

    ADType32BitUuidIncomplete = 0x04,

    ADType32BitUuidComplete = 0x05,

    ADType128BitUuidIncomplete = 0x06,

    ADType128BitUuidComplete = 0x07,

    ADTypeShortenedLocalName = 0x08,

    ADTypeCompleteLocalName = 0x09,

    ADTypeServiceData16Bit = 0x16,

    ADTypeServiceData32Bit = 0x20,

    ADTypeServiceData128Bit = 0x21,

    ADTypeManufacturerSpecificData = 0xff,

    // .. more will be added when required

};

QBluetoothDeviceInfo::CoreConfigurations qtBtTypeForJavaBtType(jint javaType)

    const JCachedBtTypes::iterator it = cachedBtTypes()->find(javaType);

    if (it == cachedBtTypes()->end()) {

        if (javaType == QJniObject::getStaticField<jint>(

                            javaBluetoothDeviceClassName, javaDeviceTypeClassic)) {

            cachedBtTypes()->insert(javaType,

                                    QBluetoothDeviceInfo::BaseRateCoreConfiguration);

            return QBluetoothDeviceInfo::BaseRateCoreConfiguration;

        } else if (javaType == QJniObject::getStaticField<jint>(

                        javaBluetoothDeviceClassName, javaDeviceTypeLE)) {

            cachedBtTypes()->insert(javaType,

                                    QBluetoothDeviceInfo::LowEnergyCoreConfiguration);

            return QBluetoothDeviceInfo::LowEnergyCoreConfiguration;

        } else if (javaType == QJniObject::getStaticField<jint>(

                            javaBluetoothDeviceClassName, javaDeviceTypeDual)) {

            cachedBtTypes()->insert(javaType,

                                    QBluetoothDeviceInfo::BaseRateAndLowEnergyCoreConfiguration);

            return QBluetoothDeviceInfo::BaseRateAndLowEnergyCoreConfiguration;

        } else if (javaType == QJniObject::getStaticField<jint>(

                                javaBluetoothDeviceClassName, javaDeviceTypeUnknown)) {

            cachedBtTypes()->insert(javaType,

                                QBluetoothDeviceInfo::UnknownCoreConfiguration);

        } else {

            qCWarning(QT_BT_ANDROID) << "Unknown Bluetooth device type value";

        return QBluetoothDeviceInfo::UnknownCoreConfiguration;

    } else {

        return it.value();

QBluetoothDeviceInfo::MajorDeviceClass resolveAndroidMajorClass(jint javaType)

    const JCachedMajorTypes::iterator it = cachedMajorTypes()->find(javaType);

    if (it == cachedMajorTypes()->end()) {

        QJniEnvironment env;

        // precache all major device class fields

        jint fieldValue;

        QBluetoothDeviceInfo::MajorDeviceClass result = QBluetoothDeviceInfo::UncategorizedDevice;

        auto clazz = env->FindClass(javaBluetoothClassDeviceMajorClassName);

        for (const auto &majorMapping : majorMappings) {

            auto fieldId = env->GetStaticFieldID(clazz, majorMapping.javaFieldName, "I");

            if (!env->ExceptionCheck())

                fieldValue = env->GetStaticIntField(clazz, fieldId);

            if (env.checkAndClearExceptions()) {

                qCWarning(QT_BT_ANDROID) << "Unknown BluetoothClass.Device.Major field" << javaType;

                // add fallback value because field not readable

                cachedMajorTypes()->insert(javaType, QBluetoothDeviceInfo::UncategorizedDevice);

            } else {

                cachedMajorTypes()->insert(fieldValue, majorMapping.qtMajor);

            if (fieldValue == javaType)

                result = majorMapping.qtMajor;

        return result;

    } else {

        return it.value();

/*

    The index for major into the MinorClassJavaToQtMapping and initializedCacheTracker

    is major+1 except for UncategorizedDevice which is at index 0.

*/

int mappingIndexForMajor(QBluetoothDeviceInfo::MajorDeviceClass major)

    int mappingIndex = (int) major;

    if (major == QBluetoothDeviceInfo::UncategorizedDevice)

        mappingIndex = 0;

    else

        mappingIndex++;

    Q_ASSERT(mappingIndex >=0

             && mappingIndex <= (QBluetoothDeviceInfo::HealthDevice + 1));

    return mappingIndex;

void triggerCachingOfMinorsForMajor(QBluetoothDeviceInfo::MajorDeviceClass major)

    //qCDebug(QT_BT_ANDROID) << "Caching minor values for major" << major;

    int mappingIndex = mappingIndexForMajor(major);

    quint8 sizeIndex = minorIndexSizes[mappingIndex];

    while (minorMappings[sizeIndex].javaFieldName != nullptr) {

        jint fieldValue = QJniObject::getStaticField<jint>(

                    javaBluetoothClassDeviceClassName, minorMappings[sizeIndex].javaFieldName);

        Q_ASSERT(fieldValue >= 0);

        cachedMinorTypes()->insert(fieldValue, minorMappings[sizeIndex].qtMinor);

        sizeIndex++;

    initializedCacheTracker()->setBit(mappingIndex);

quint8 resolveAndroidMinorClass(QBluetoothDeviceInfo::MajorDeviceClass major, jint javaMinor)

    // there are no minor device classes in java with value 0

    //qCDebug(QT_BT_ANDROID) << "received minor class device:" << javaMinor;

    if (javaMinor == 0)

        return 0;

    int mappingIndex = mappingIndexForMajor(major);

    // whenever we encounter a not yet seen major device class

    // we populate the cache with all its related minor values

    if (!initializedCacheTracker()->at(mappingIndex))

        triggerCachingOfMinorsForMajor(major);

    const JCachedMinorTypes::iterator it = cachedMinorTypes()->find(javaMinor);

    if (it == cachedMinorTypes()->end())

        return 0;

    else

        return it.value();

DeviceDiscoveryBroadcastReceiver::DeviceDiscoveryBroadcastReceiver(QObject* parent): AndroidBroadcastReceiver(parent)

    addAction(QJniObject::fromString(

        valueForStaticField<QtJniTypes::BluetoothDevice, JavaNames::ActionFound>()));

    addAction(QJniObject::fromString(

        valueForStaticField<QtJniTypes::BluetoothAdapter, JavaNames::ActionDiscoveryStarted>()));

    addAction(QJniObject::fromString(

        valueForStaticField<QtJniTypes::BluetoothAdapter, JavaNames::ActionDiscoveryFinished>()));

// Runs in Java thread

void DeviceDiscoveryBroadcastReceiver::onReceive(JNIEnv *env, jobject context, jobject intent)

    Q_UNUSED(context)

    Q_UNUSED(env)

    QJniObject intentObject(intent);

    const QString action = intentObject.callMethod<jstring>("getAction").toString();

    qCDebug(QT_BT_ANDROID) << "DeviceDiscoveryBroadcastReceiver::onReceive() - event:" << action;

    if (action == valueForStaticField<QtJniTypes::BluetoothAdapter,

                                      JavaNames::ActionDiscoveryFinished>()) {

        emit finished();

    } else if (action == valueForStaticField<QtJniTypes::BluetoothAdapter,

                                             JavaNames::ActionDiscoveryStarted>()) {

        emit discoveryStarted();

    } else if (action == valueForStaticField<QtJniTypes::BluetoothDevice,

                                             JavaNames::ActionFound>()) {

        //get BluetoothDevice

        QJniObject keyExtra =

            QJniObject::fromString(valueForStaticField<QtJniTypes::BluetoothDevice,

                                                       JavaNames::ExtraDevice>());

        const QJniObject bluetoothDevice =

                intentObject.callMethod<QtJniTypes::Parcelable>("getParcelableExtra",

                                                                keyExtra.object<jstring>());

        if (!bluetoothDevice.isValid())

            return;

        keyExtra = QJniObject::fromString(valueForStaticField<QtJniTypes::BluetoothDevice,

                                                              JavaNames::ExtraRssi>());

        int rssi = intentObject.callMethod<jshort>("getShortExtra",

                                                   keyExtra.object<jstring>(), jshort(0));

        const QBluetoothDeviceInfo info = retrieveDeviceInfo(bluetoothDevice, rssi);

        if (info.isValid())

            emit deviceDiscovered(info, false);

// Runs in Java thread

void DeviceDiscoveryBroadcastReceiver::onReceiveLeScan(

        JNIEnv */*env*/, jobject jBluetoothDevice, jint rssi, jbyteArray scanRecord)

    const QJniObject bluetoothDevice(jBluetoothDevice);

    if (!bluetoothDevice.isValid())

        return;

    const QBluetoothDeviceInfo info = retrieveDeviceInfo(bluetoothDevice, rssi, scanRecord);

    if (info.isValid())

        emit deviceDiscovered(info, true);

Q_BLUETOOTH_EXPORT void parseScanRecord(QBluetoothDeviceInfo &info, jbyteArray scanRecord)

    Q_ASSERT(scanRecord != nullptr);

    QJniEnvironment env;

    // Parse scan record

    jboolean isCopy;

    jbyte *elems = env->GetByteArrayElements(scanRecord, &isCopy);

    const char *scanRecordBuffer = reinterpret_cast<const char *>(elems);

    const jsize scanRecordLength = env->GetArrayLength(scanRecord);

    QList<QBluetoothUuid> serviceUuids;

    jsize i = 0;

    // Spec 4.2, Vol 3, Part C, Chapter 11

    QString localName;

    while (i < scanRecordLength) {

        // sizeof(EIR Data) = sizeof(Length) + sizeof(EIR data Type) + sizeof(EIR Data)

        // Length = sizeof(EIR data Type) + sizeof(EIR Data)

        const int nBytes = quint8(scanRecordBuffer[i]);

        if (nBytes == 0)

            break;

        if (i >= scanRecordLength - nBytes)

            break;

        const int adType = quint8(scanRecordBuffer[i+1]);

        const char *dataPtr = &scanRecordBuffer[i+2];

        QBluetoothUuid foundService;

        switch (adType) {

        case ADType16BitUuidIncomplete:

        case ADType16BitUuidComplete:

            if (nBytes >= 3)

                foundService = QBluetoothUuid(qFromLittleEndian<quint16>(dataPtr));

            break;

        case ADType32BitUuidIncomplete:

        case ADType32BitUuidComplete:

            if (nBytes >= 5)

                foundService = QBluetoothUuid(qFromLittleEndian<quint32>(dataPtr));

            break;

        case ADType128BitUuidIncomplete:

        case ADType128BitUuidComplete:

            if (nBytes >= 17) {

                foundService =

                    QBluetoothUuid(qToBigEndian<QUuid::Id128Bytes>(qFromLittleEndian<QUuid::Id128Bytes>(dataPtr)));

            break;

        case ADTypeServiceData16Bit:

            if (nBytes >= 3) {

                info.setServiceData(QBluetoothUuid(qFromLittleEndian<quint16>(dataPtr)),

                                    QByteArray(dataPtr + 2, nBytes - 3));

            break;

        case ADTypeServiceData32Bit:

            if (nBytes >= 5) {

                info.setServiceData(QBluetoothUuid(qFromLittleEndian<quint32>(dataPtr)),

                                    QByteArray(dataPtr + 4, nBytes - 5));

            break;

        case ADTypeServiceData128Bit:

            if (nBytes >= 17) {

                info.setServiceData(QBluetoothUuid(qToBigEndian<QUuid::Id128Bytes>(

                                            qFromLittleEndian<QUuid::Id128Bytes>(dataPtr))),

                                    QByteArray(dataPtr + 16, nBytes - 17));

            break;

        case ADTypeManufacturerSpecificData:

            if (nBytes >= 3) {

                info.setManufacturerData(qFromLittleEndian<quint16>(dataPtr),

                                            QByteArray(dataPtr + 2, nBytes - 3));

            break;

        // According to Spec 5.0, Vol 3, Part C, Chapter 12.1

        // the device's local  name is utf8 encoded

        case ADTypeShortenedLocalName:

            if (localName.isEmpty())

                localName = QString::fromUtf8(dataPtr, nBytes - 1);

            break;

        case ADTypeCompleteLocalName:

            localName = QString::fromUtf8(dataPtr, nBytes - 1);

            break;

        default:

            // qWarning() << "Unhandled AD Type" << Qt::hex << adType;

            // no other types supported yet and therefore skipped

            // https://www.bluetooth.com/specifications/assigned-numbers/generic-access-profile

            break;

        i += nBytes + 1;

        if (!foundService.isNull() && !serviceUuids.contains(foundService))

            serviceUuids.append(foundService);

    if (info.name().isEmpty())

        info.setName(localName);

    info.setServiceUuids(serviceUuids);

    env->ReleaseByteArrayElements(scanRecord, elems, JNI_ABORT);

QBluetoothDeviceInfo DeviceDiscoveryBroadcastReceiver::retrieveDeviceInfo(const QJniObject &bluetoothDevice, int rssi, jbyteArray scanRecord)

    const QString deviceName = bluetoothDevice.callMethod<jstring>("getName").toString();

    const QBluetoothAddress deviceAddress(

                bluetoothDevice.callMethod<jstring>("getAddress").toString());

    const QJniObject bluetoothClass =

            bluetoothDevice.callMethod<QtJniTypes::BluetoothClass>("getBluetoothClass");

    if (!bluetoothClass.isValid())

        return QBluetoothDeviceInfo();

    QBluetoothDeviceInfo::MajorDeviceClass majorClass = resolveAndroidMajorClass(

                                bluetoothClass.callMethod<jint>("getMajorDeviceClass"));

    // major device class is 5 bits from index 8 - 12

    quint32 classType = ((quint32(majorClass) & 0x1f) << 8);

    jint javaMinor = bluetoothClass.callMethod<jint>("getDeviceClass");

    quint8 minorDeviceType = resolveAndroidMinorClass(majorClass, javaMinor);

    // minor device class is 6 bits from index 2 - 7

    classType |= ((quint32(minorDeviceType) & 0x3f) << 2);

    static constexpr quint32 services[] = {

        QBluetoothDeviceInfo::PositioningService,

        QBluetoothDeviceInfo::NetworkingService,

        QBluetoothDeviceInfo::RenderingService,

        QBluetoothDeviceInfo::CapturingService,

        QBluetoothDeviceInfo::ObjectTransferService,

        QBluetoothDeviceInfo::AudioService,

        QBluetoothDeviceInfo::TelephonyService,

        QBluetoothDeviceInfo::InformationService,

};

    // Matching BluetoothClass.Service values

    quint32 serviceResult = 0;

    for (quint32 current : services) {

        int androidId = (current << 16); // Android values shift by 2 bytes compared to Qt enums

        if (bluetoothClass.callMethod<jboolean>("hasService", androidId))

            serviceResult |= current;

    // service class info is 11 bits from index 13 - 23

    classType |= (serviceResult << 13);

    QBluetoothDeviceInfo info(deviceAddress, deviceName, classType);

    info.setRssi(rssi);

    QJniEnvironment env;

    if (scanRecord != nullptr)

        parseScanRecord(info, scanRecord);

    auto methodId = env.findMethod(bluetoothDevice.objectClass(), "getType", "()I");

    jint javaBtType = env->CallIntMethod(bluetoothDevice.object(), methodId);

    if (!env.checkAndClearExceptions()) {

        info.setCoreConfigurations(qtBtTypeForJavaBtType(javaBtType));

    return info;

#if defined(Q_OS_ANDROID)

Q_BLUETOOTH_EXPORT void testEnumToString(std::function<void(const char*, int)> callback)

    for (const auto &entry : minorMappings) {

        if (entry.javaFieldName) {

            callback(entry.javaFieldName, entry.qtMinor);

#endif

QT_END_NAMESPACE

Revision control

Copy as Markdown