Revision control
++ // 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 "qlowenergycontroller_android_p.h"
++ #include "android/androidutils_p.h"
++ #include "android/jni_android_p.h"
++ #include <QCoreApplication>
++ #include <QtCore/QLoggingCategory>
++ #include <QtCore/QJniEnvironment>
++ #include <QtCore/QJniObject>
++ #include <QtCore/q26numeric.h>
++ #include <QtBluetooth/QLowEnergyServiceData>
++ #include <QtBluetooth/QLowEnergyCharacteristicData>
++ #include <QtBluetooth/QLowEnergyDescriptorData>
++ #include <QtBluetooth/QLowEnergyAdvertisingData>
++ #include <QtBluetooth/QLowEnergyAdvertisingParameters>
++ #include <QtBluetooth/QLowEnergyConnectionParameters>
++
++ QT_BEGIN_NAMESPACE
++
++ Q_DECLARE_LOGGING_CATEGORY(QT_BT_ANDROID)
++
++ // BT Core v5.3, 3.2.9, Vol 3, Part F
++ const int BTLE_MAX_ATTRIBUTE_VALUE_SIZE = 512;
++
++ // Conversion: QBluetoothUuid -> java.util.UUID
++ static QJniObject javaUuidfromQtUuid(const QBluetoothUuid& uuid)
++ {
++ // cut off leading and trailing brackets
++ const QString output = uuid.toString(QUuid::WithoutBraces);
++
++ QJniObject javaString = QJniObject::fromString(output);
++ QJniObject javaUuid = QJniObject::callStaticMethod<QtJniTypes::UUID>(
++ QtJniTypes::Traits<QtJniTypes::UUID>::className(), "fromString",
++ javaString.object<jstring>());
++
++ return javaUuid;
++ }
++
++ QLowEnergyControllerPrivateAndroid::QLowEnergyControllerPrivateAndroid()
++ : QLowEnergyControllerPrivate(),
++ hub(0)
++ {
++ registerQLowEnergyControllerMetaType();
++ }
++
++ QLowEnergyControllerPrivateAndroid::~QLowEnergyControllerPrivateAndroid()
++ {
++ if (role == QLowEnergyController::PeripheralRole) {
++ if (hub)
++ hub->javaObject().callMethod<void>("disconnectServer");
++ }
++ }
++
++ void QLowEnergyControllerPrivateAndroid::init()
++ {
++ const bool isPeripheral = (role == QLowEnergyController::PeripheralRole);
++
++ if (isPeripheral) {
++ qRegisterMetaType<QJniObject>();
++ hub = new LowEnergyNotificationHub(remoteDevice, isPeripheral, this);
++ // we only connect to the peripheral role specific signals
++ // TODO add connections as they get added later on
++ connect(hub, &LowEnergyNotificationHub::connectionUpdated,
++ this, &QLowEnergyControllerPrivateAndroid::connectionUpdated);
++ connect(hub, &LowEnergyNotificationHub::mtuChanged,
++ this, &QLowEnergyControllerPrivateAndroid::mtuChanged);
++ connect(hub, &LowEnergyNotificationHub::advertisementError,
++ this, &QLowEnergyControllerPrivateAndroid::advertisementError);
++ connect(hub, &LowEnergyNotificationHub::serverCharacteristicChanged,
++ this, &QLowEnergyControllerPrivateAndroid::serverCharacteristicChanged);
++ connect(hub, &LowEnergyNotificationHub::serverDescriptorWritten,
++ this, &QLowEnergyControllerPrivateAndroid::serverDescriptorWritten);
++ } else {
++ hub = new LowEnergyNotificationHub(remoteDevice, isPeripheral, this);
++ // we only connect to the central role specific signals
++ connect(hub, &LowEnergyNotificationHub::connectionUpdated,
++ this, &QLowEnergyControllerPrivateAndroid::connectionUpdated);
++ connect(hub, &LowEnergyNotificationHub::mtuChanged,
++ this, &QLowEnergyControllerPrivateAndroid::mtuChanged);
++ connect(hub, &LowEnergyNotificationHub::servicesDiscovered,
++ this, &QLowEnergyControllerPrivateAndroid::servicesDiscovered);
++ connect(hub, &LowEnergyNotificationHub::serviceDetailsDiscoveryFinished,
++ this, &QLowEnergyControllerPrivateAndroid::serviceDetailsDiscoveryFinished);
++ connect(hub, &LowEnergyNotificationHub::characteristicRead,
++ this, &QLowEnergyControllerPrivateAndroid::characteristicRead);
++ connect(hub, &LowEnergyNotificationHub::descriptorRead,
++ this, &QLowEnergyControllerPrivateAndroid::descriptorRead);
++ connect(hub, &LowEnergyNotificationHub::characteristicWritten,
++ this, &QLowEnergyControllerPrivateAndroid::characteristicWritten);
++ connect(hub, &LowEnergyNotificationHub::descriptorWritten,
++ this, &QLowEnergyControllerPrivateAndroid::descriptorWritten);
++ connect(hub, &LowEnergyNotificationHub::characteristicChanged,
++ this, &QLowEnergyControllerPrivateAndroid::characteristicChanged);
++ connect(hub, &LowEnergyNotificationHub::serviceError,
++ this, &QLowEnergyControllerPrivateAndroid::serviceError);
++ connect(hub, &LowEnergyNotificationHub::remoteRssiRead,
++ this, &QLowEnergyControllerPrivateAndroid::remoteRssiRead);
++ }
++ }
++
++ void QLowEnergyControllerPrivateAndroid::connectToDevice()
++ {
++ if (!hub) {
++ qCCritical(QT_BT_ANDROID) << "connectToDevice() LE controller has not been initialized";
++ return;
++ }
++
++ if (!ensureAndroidPermission(QBluetoothPermission::Access)) {
++ // This is unlikely to happen as a valid local adapter is a precondition
++ setError(QLowEnergyController::MissingPermissionsError);
++ qCWarning(QT_BT_ANDROID) << "connectToDevice() failed due to missing permissions";
++ return;
++ }
++
++ // required to pass unit test on default backend
++ if (remoteDevice.isNull()) {
++ qCWarning(QT_BT_ANDROID) << "Invalid/null remote device address";
++ setError(QLowEnergyController::UnknownRemoteDeviceError);
++ return;
++ }
++
++ setState(QLowEnergyController::ConnectingState);
++
++ if (!hub->javaObject().isValid()) {
++ qCWarning(QT_BT_ANDROID) << "Cannot initiate QtBluetoothLE";
++ setError(QLowEnergyController::ConnectionError);
++ setState(QLowEnergyController::UnconnectedState);
++ return;
++ }
++
++ bool result = hub->javaObject().callMethod<jboolean>("connect");
++ if (!result) {
++ setError(QLowEnergyController::ConnectionError);
++ setState(QLowEnergyController::UnconnectedState);
++ return;
++ }
++ }
++
++ void QLowEnergyControllerPrivateAndroid::disconnectFromDevice()
++ {
++ /* Catch an Android timeout bug. If the device is connecting but cannot
++ * physically connect it seems to ignore the disconnect call below.
++ * At least BluetoothGattCallback.onConnectionStateChange never
++ * arrives. The next BluetoothGatt.connect() works just fine though.
++ * */
++
++ QLowEnergyController::ControllerState oldState = state;
++ setState(QLowEnergyController::ClosingState);
++
++ if (hub) {
++ if (role == QLowEnergyController::PeripheralRole)
++ hub->javaObject().callMethod<void>("disconnectServer");
++ else
++ hub->javaObject().callMethod<void>("disconnect");
++ }
++
++ if (oldState == QLowEnergyController::ConnectingState)
++ setState(QLowEnergyController::UnconnectedState);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::discoverServices()
++ {
++ // No need to check bluetooth permissions here as 'connected' is a precondition
++
++ if (hub && hub->javaObject().callMethod<jboolean>("discoverServices")) {
++ qCDebug(QT_BT_ANDROID) << "Service discovery initiated";
++ } else {
++ //revert to connected state
++ setError(QLowEnergyController::NetworkError);
++ setState(QLowEnergyController::ConnectedState);
++ }
++ }
++
++ void QLowEnergyControllerPrivateAndroid::discoverServiceDetails(
++ const QBluetoothUuid &service, QLowEnergyService::DiscoveryMode mode)
++ {
++ Q_UNUSED(mode);
++ if (!serviceList.contains(service)) {
++ qCWarning(QT_BT_ANDROID) << "Discovery of unknown service" << service.toString()
++ << "not possible";
++ return;
++ }
++
++ if (!hub)
++ return;
++
++ QString tempUuid = service.toString(QUuid::WithoutBraces);
++
++ QJniEnvironment env;
++ QJniObject uuid = QJniObject::fromString(tempUuid);
++ bool readAllValues = mode == QLowEnergyService::FullDiscovery;
++ bool result = hub->javaObject().callMethod<jboolean>("discoverServiceDetails",
++ uuid.object<jstring>(),
++ readAllValues);
++ if (!result) {
++ QSharedPointer<QLowEnergyServicePrivate> servicePrivate =
++ serviceList.value(service);
++ if (!servicePrivate.isNull()) {
++ servicePrivate->setError(QLowEnergyService::UnknownError);
++ servicePrivate->setState(QLowEnergyService::RemoteService);
++ }
++ qCWarning(QT_BT_ANDROID) << "Cannot discover details for" << service.toString();
++ return;
++ }
++
++ qCDebug(QT_BT_ANDROID) << "Discovery of" << service << "started";
++ }
++
++ void QLowEnergyControllerPrivateAndroid::writeCharacteristic(
++ const QSharedPointer<QLowEnergyServicePrivate> service,
++ const QLowEnergyHandle charHandle,
++ const QByteArray &newValue,
++ QLowEnergyService::WriteMode mode)
++ {
++ //TODO don't ignore WriteWithResponse, right now we assume responses
++ Q_ASSERT(!service.isNull());
++
++ if (!service->characteristicList.contains(charHandle))
++ return;
++
++ QJniEnvironment env;
++ const jsize nativeSize = q26::saturate_cast<jsize>(newValue.size());
++ jbyteArray payload;
++ payload = env->NewByteArray(nativeSize);
++ env->SetByteArrayRegion(payload, 0, nativeSize,
++ (jbyte *)newValue.constData());
++
++ bool result = false;
++ if (hub) {
++ if (role == QLowEnergyController::CentralRole) {
++ qCDebug(QT_BT_ANDROID) << "Write characteristic with handle " << charHandle
++ << newValue.toHex() << "(service:" << service->uuid
++ << ", writeWithResponse:" << (mode == QLowEnergyService::WriteWithResponse)
++ << ", signed:" << (mode == QLowEnergyService::WriteSigned) << ")";
++ result = hub->javaObject().callMethod<jboolean>("writeCharacteristic",
++ charHandle, payload, jint(mode));
++ } else { // peripheral mode
++ qCDebug(QT_BT_ANDROID) << "Write server characteristic with handle " << charHandle
++ << newValue.toHex() << "(service:" << service->uuid;
++
++ const auto &characteristic = characteristicForHandle(charHandle);
++ if (characteristic.isValid()) {
++ const QJniObject charUuid = javaUuidfromQtUuid(characteristic.uuid());
++ result = hub->javaObject().callMethod<jboolean>(
++ "writeCharacteristic",
++ service->androidService.object<QtJniTypes::BluetoothGattService>(),
++ charUuid.object<QtJniTypes::UUID>(), payload);
++ if (result)
++ service->characteristicList[charHandle].value = newValue;
++ }
++ }
++ }
++
++ env->DeleteLocalRef(payload);
++
++ if (!result)
++ service->setError(QLowEnergyService::CharacteristicWriteError);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::writeDescriptor(
++ const QSharedPointer<QLowEnergyServicePrivate> service,
++ const QLowEnergyHandle charHandle,
++ const QLowEnergyHandle descHandle,
++ const QByteArray &newValue)
++ {
++ Q_ASSERT(!service.isNull());
++
++ QJniEnvironment env;
++ const jsize nativeSize = q26::saturate_cast<jsize>(newValue.size());
++ jbyteArray payload;
++ payload = env->NewByteArray(nativeSize);
++ env->SetByteArrayRegion(payload, 0, nativeSize,
++ (jbyte *)newValue.constData());
++
++ bool result = false;
++ if (hub) {
++ if (role == QLowEnergyController::CentralRole) {
++ qCDebug(QT_BT_ANDROID) << "Write descriptor with handle " << descHandle
++ << newValue.toHex() << "(service:" << service->uuid << ")";
++ result = hub->javaObject().callMethod<jboolean>("writeDescriptor",
++ descHandle, payload);
++ } else {
++ const auto &characteristic = characteristicForHandle(charHandle);
++ const auto &descriptor = descriptorForHandle(descHandle);
++ if (characteristic.isValid() && descriptor.isValid()) {
++ qCDebug(QT_BT_ANDROID) << "Write descriptor" << descriptor.uuid()
++ << "(service:" << service->uuid
++ << "char: " << characteristic.uuid() << ")";
++ const QJniObject charUuid = javaUuidfromQtUuid(characteristic.uuid());
++ const QJniObject descUuid = javaUuidfromQtUuid(descriptor.uuid());
++ result = hub->javaObject().callMethod<jboolean>(
++ "writeDescriptor",
++ service->androidService.object<QtJniTypes::BluetoothGattService>(),
++ charUuid.object<QtJniTypes::UUID>(), descUuid.object<QtJniTypes::UUID>(),
++ payload);
++ if (result)
++ service->characteristicList[charHandle].descriptorList[descHandle].value = newValue;
++ }
++ }
++ }
++
++ env->DeleteLocalRef(payload);
++
++ if (!result)
++ service->setError(QLowEnergyService::DescriptorWriteError);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::readCharacteristic(
++ const QSharedPointer<QLowEnergyServicePrivate> service,
++ const QLowEnergyHandle charHandle)
++ {
++ Q_ASSERT(!service.isNull());
++
++ if (!service->characteristicList.contains(charHandle))
++ return;
++
++ QJniEnvironment env;
++ bool result = false;
++ if (hub) {
++ qCDebug(QT_BT_ANDROID) << "Read characteristic with handle"
++ << charHandle << service->uuid;
++ result = hub->javaObject().callMethod<jboolean>("readCharacteristic", charHandle);
++ }
++
++ if (!result)
++ service->setError(QLowEnergyService::CharacteristicReadError);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::readDescriptor(
++ const QSharedPointer<QLowEnergyServicePrivate> service,
++ const QLowEnergyHandle /*charHandle*/,
++ const QLowEnergyHandle descriptorHandle)
++ {
++ Q_ASSERT(!service.isNull());
++
++ QJniEnvironment env;
++ bool result = false;
++ if (hub) {
++ qCDebug(QT_BT_ANDROID) << "Read descriptor with handle"
++ << descriptorHandle << service->uuid;
++ result = hub->javaObject().callMethod<jboolean>("readDescriptor", descriptorHandle);
++ }
++
++ if (!result)
++ service->setError(QLowEnergyService::DescriptorReadError);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::connectionUpdated(
++ QLowEnergyController::ControllerState newState,
++ QLowEnergyController::Error errorCode)
++ {
++ qCDebug(QT_BT_ANDROID) << "Connection updated:"
++ << "error:" << errorCode
++ << "oldState:" << state
++ << "newState:" << newState;
++
++ if (role == QLowEnergyController::PeripheralRole)
++ peripheralConnectionUpdated(newState, errorCode);
++ else
++ centralConnectionUpdated(newState, errorCode);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::mtuChanged(int mtu)
++ {
++ Q_Q(QLowEnergyController);
++ qCDebug(QT_BT_ANDROID) << "MTU updated:"
++ << "mtu:" << mtu;
++ emit q->mtuChanged(mtu);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::remoteRssiRead(int rssi, bool success)
++ {
++ Q_Q(QLowEnergyController);
++ if (success) {
++ // BT Core v5.3, 7.5.4, Vol 4, Part E
++ // The LE RSSI can take values -127..127 => narrowing to qint16 is safe
++ emit q->rssiRead(rssi);
++ } else {
++ qCDebug(QT_BT_ANDROID) << "Reading remote RSSI failed";
++ setError(QLowEnergyController::RssiReadError);
++ }
++ }
++
++ // called if server/peripheral
++ void QLowEnergyControllerPrivateAndroid::peripheralConnectionUpdated(
++ QLowEnergyController::ControllerState newState,
++ QLowEnergyController::Error errorCode)
++ {
++ // Java errorCode can be larger than max QLowEnergyController::Error
++ if (errorCode > QLowEnergyController::AdvertisingError)
++ errorCode = QLowEnergyController::UnknownError;
++
++ if (errorCode != QLowEnergyController::NoError)
++ setError(errorCode);
++
++ const QLowEnergyController::ControllerState oldState = state;
++ setState(newState);
++
++ // disconnect implies stop of advertisement
++ if (newState == QLowEnergyController::UnconnectedState)
++ stopAdvertising();
++
++ // The remote name and address may have changed
++ if (hub) {
++ remoteDevice = QBluetoothAddress(
++ hub->javaObject().callMethod<jstring>("remoteAddress").toString());
++ remoteName = hub->javaObject().callMethod<jstring>("remoteName").toString();
++ }
++
++ Q_Q(QLowEnergyController);
++ // Emit (dis)connected if the connection state changes
++ if (oldState == QLowEnergyController::ConnectedState
++ && newState != QLowEnergyController::ConnectedState) {
++ emit q->disconnected();
++ } else if (newState == QLowEnergyController::ConnectedState
++ && oldState != QLowEnergyController::ConnectedState) {
++ emit q->connected();
++ }
++ }
++
++ // called if client/central
++ void QLowEnergyControllerPrivateAndroid::centralConnectionUpdated(
++ QLowEnergyController::ControllerState newState,
++ QLowEnergyController::Error errorCode)
++ {
++ Q_Q(QLowEnergyController);
++
++ const QLowEnergyController::ControllerState oldState = state;
++
++ if (errorCode != QLowEnergyController::NoError) {
++ // ConnectionError if transition from Connecting to Connected
++ if (oldState == QLowEnergyController::ConnectingState) {
++ setError(QLowEnergyController::ConnectionError);
++ /* There is a bug in Android, when connecting to an unconnectable
++ * device. The connection times out and Android sends error code
++ * 133 (doesn't exist) and STATE_CONNECTED. A subsequent disconnect()
++ * call never sends a STATE_DISCONNECTED either.
++ * As workaround we will trigger disconnect when we encounter
++ * error during connect attempt. This leaves the controller
++ * in a cleaner state.
++ * */
++ newState = QLowEnergyController::UnconnectedState;
++ }
++ else
++ setError(errorCode);
++ }
++
++ setState(newState);
++ if (newState == QLowEnergyController::UnconnectedState
++ && !(oldState == QLowEnergyController::UnconnectedState
++ || oldState == QLowEnergyController::ConnectingState)) {
++
++ // Invalidate the services if the disconnect came from the remote end.
++ // Qtherwise we disconnected via QLowEnergyController::disconnectDevice() which
++ // triggered invalidation already
++ if (!serviceList.isEmpty()) {
++ Q_ASSERT(oldState != QLowEnergyController::ClosingState);
++ invalidateServices();
++ }
++ emit q->disconnected();
++ } else if (newState == QLowEnergyController::ConnectedState
++ && oldState != QLowEnergyController::ConnectedState ) {
++ emit q->connected();
++ }
++ }
++
++ void QLowEnergyControllerPrivateAndroid::servicesDiscovered(
++ QLowEnergyController::Error errorCode, const QString &foundServices)
++ {
++ Q_Q(QLowEnergyController);
++
++ if (errorCode == QLowEnergyController::NoError) {
++ //Android delivers all services in one go
++ const QStringList list = foundServices.split(QChar::Space, Qt::SkipEmptyParts);
++ for (const QString &entry : list) {
++ const QBluetoothUuid service(entry);
++ if (service.isNull())
++ return;
++
++ QLowEnergyServicePrivate *priv = new QLowEnergyServicePrivate();
++ priv->uuid = service;
++ priv->setController(this);
++
++ QSharedPointer<QLowEnergyServicePrivate> pointer(priv);
++ serviceList.insert(service, pointer);
++
++ emit q->serviceDiscovered(QBluetoothUuid(entry));
++ }
++
++ setState(QLowEnergyController::DiscoveredState);
++ emit q->discoveryFinished();
++ } else {
++ setError(errorCode);
++ setState(QLowEnergyController::ConnectedState);
++ }
++ }
++
++ void QLowEnergyControllerPrivateAndroid::serviceDetailsDiscoveryFinished(
++ const QString &serviceUuid, int startHandle, int endHandle)
++ {
++ const QBluetoothUuid service(serviceUuid);
++ if (!serviceList.contains(service)) {
++ qCWarning(QT_BT_ANDROID) << "Discovery done of unknown service:"
++ << service.toString();
++ return;
++ }
++
++ //update service data
++ QSharedPointer<QLowEnergyServicePrivate> pointer =
++ serviceList.value(service);
++ pointer->startHandle = startHandle;
++ pointer->endHandle = endHandle;
++
++ if (hub && hub->javaObject().isValid()) {
++ QJniObject uuid = QJniObject::fromString(serviceUuid);
++ QJniObject javaIncludes = hub->javaObject().callMethod<jstring>(
++ "includedServices", uuid.object<jstring>());
++ if (javaIncludes.isValid()) {
++ const QStringList list = javaIncludes.toString()
++ .split(QChar::Space, Qt::SkipEmptyParts);
++ for (const QString &entry : list) {
++ const QBluetoothUuid service(entry);
++ if (service.isNull())
++ return;
++
++ pointer->includedServices.append(service);
++
++ // update the type of the included service
++ QSharedPointer<QLowEnergyServicePrivate> otherService =
++ serviceList.value(service);
++ if (!otherService.isNull())
++ otherService->type |= QLowEnergyService::IncludedService;
++ }
++ }
++ }
++
++ qCDebug(QT_BT_ANDROID) << "Service" << serviceUuid << "discovered (start:"
++ << startHandle << "end:" << endHandle << ")" << pointer.data();
++
++ pointer->setState(QLowEnergyService::RemoteServiceDiscovered);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::characteristicRead(
++ const QBluetoothUuid &serviceUuid, int handle,
++ const QBluetoothUuid &charUuid, int properties, const QByteArray &data)
++ {
++ if (!serviceList.contains(serviceUuid))
++ return;
++
++ QSharedPointer<QLowEnergyServicePrivate> service =
++ serviceList.value(serviceUuid);
++ QLowEnergyHandle charHandle = handle;
++
++ QLowEnergyServicePrivate::CharData &charDetails =
++ service->characteristicList[charHandle];
++
++ //Android uses same property value as Qt which is the Bluetooth LE standard
++ charDetails.properties = QLowEnergyCharacteristic::PropertyType(properties);
++ charDetails.uuid = charUuid;
++ charDetails.value = data;
++ //value handle always one larger than characteristics value handle
++ charDetails.valueHandle = charHandle + 1;
++
++ if (service->state == QLowEnergyService::RemoteServiceDiscovered) {
++ QLowEnergyCharacteristic characteristic = characteristicForHandle(charHandle);
++ if (!characteristic.isValid()) {
++ qCWarning(QT_BT_ANDROID) << "characteristicRead: Cannot find characteristic";
++ return;
++ }
++ emit service->characteristicRead(characteristic, data);
++ }
++ }
++
++ void QLowEnergyControllerPrivateAndroid::descriptorRead(
++ const QBluetoothUuid &serviceUuid, const QBluetoothUuid &charUuid,
++ int descHandle, const QBluetoothUuid &descUuid, const QByteArray &data)
++ {
++ if (!serviceList.contains(serviceUuid))
++ return;
++
++ QSharedPointer<QLowEnergyServicePrivate> service =
++ serviceList.value(serviceUuid);
++
++ bool entryUpdated = false;
++
++ CharacteristicDataMap::iterator charIt = service->characteristicList.begin();
++ for ( ; charIt != service->characteristicList.end(); ++charIt) {
++ QLowEnergyServicePrivate::CharData &charDetails = charIt.value();
++
++ if (charDetails.uuid != charUuid)
++ continue;
++
++ // new entry created if it doesn't exist
++ QLowEnergyServicePrivate::DescData &descDetails =
++ charDetails.descriptorList[descHandle];
++ descDetails.uuid = descUuid;
++ descDetails.value = data;
++ entryUpdated = true;
++ break;
++ }
++
++ if (!entryUpdated) {
++ qCWarning(QT_BT_ANDROID) << "Cannot find/update descriptor"
++ << descUuid << charUuid << serviceUuid;
++ } else if (service->state == QLowEnergyService::RemoteServiceDiscovered){
++ QLowEnergyDescriptor descriptor = descriptorForHandle(descHandle);
++ if (!descriptor.isValid()) {
++ qCWarning(QT_BT_ANDROID) << "descriptorRead: Cannot find descriptor";
++ return;
++ }
++ emit service->descriptorRead(descriptor, data);
++ }
++ }
++
++ void QLowEnergyControllerPrivateAndroid::characteristicWritten(
++ int charHandle, const QByteArray &data, QLowEnergyService::ServiceError errorCode)
++ {
++ QSharedPointer<QLowEnergyServicePrivate> service =
++ serviceForHandle(charHandle);
++ if (service.isNull())
++ return;
++
++ qCDebug(QT_BT_ANDROID) << "Characteristic write confirmation" << service->uuid
++ << charHandle << data.toHex() << errorCode;
++
++ if (errorCode != QLowEnergyService::NoError) {
++ service->setError(errorCode);
++ return;
++ }
++
++ QLowEnergyCharacteristic characteristic = characteristicForHandle(charHandle);
++ if (!characteristic.isValid()) {
++ qCWarning(QT_BT_ANDROID) << "characteristicWritten: Cannot find characteristic";
++ return;
++ }
++
++ // only update cache when property is readable. Otherwise it remains
++ // empty.
++ if (characteristic.properties() & QLowEnergyCharacteristic::Read)
++ updateValueOfCharacteristic(charHandle, data, false);
++ emit service->characteristicWritten(characteristic, data);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::descriptorWritten(
++ int descHandle, const QByteArray &data, QLowEnergyService::ServiceError errorCode)
++ {
++ QSharedPointer<QLowEnergyServicePrivate> service =
++ serviceForHandle(descHandle);
++ if (service.isNull())
++ return;
++
++ qCDebug(QT_BT_ANDROID) << "Descriptor write confirmation" << service->uuid
++ << descHandle << data.toHex() << errorCode;
++
++ if (errorCode != QLowEnergyService::NoError) {
++ service->setError(errorCode);
++ return;
++ }
++
++ QLowEnergyDescriptor descriptor = descriptorForHandle(descHandle);
++ if (!descriptor.isValid()) {
++ qCWarning(QT_BT_ANDROID) << "descriptorWritten: Cannot find descriptor";
++ return;
++ }
++
++ updateValueOfDescriptor(descriptor.characteristicHandle(),
++ descHandle, data, false);
++ emit service->descriptorWritten(descriptor, data);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::serverDescriptorWritten(
++ const QJniObject &jniDesc, const QByteArray &newValue)
++ {
++ qCDebug(QT_BT_ANDROID) << "Server descriptor change notification" << newValue.toHex();
++
++ // retrieve service, char and desc uuids
++ const QJniObject jniChar = jniDesc.callMethod<QtJniTypes::BluetoothGattCharacteristic>(
++ "getCharacteristic");
++ if (!jniChar.isValid())
++ return;
++
++ const QJniObject jniService =
++ jniChar.callMethod<QtJniTypes::BluetoothGattService>("getService");
++ if (!jniService.isValid())
++ return;
++
++ QJniObject jniUuid = jniService.callMethod<QtJniTypes::UUID>("getUuid");
++ const QBluetoothUuid serviceUuid(jniUuid.toString());
++ if (serviceUuid.isNull())
++ return;
++
++ // TODO test if two service with same uuid exist
++ if (!localServices.contains(serviceUuid))
++ return;
++
++ jniUuid = jniChar.callMethod<QtJniTypes::UUID>("getUuid");
++ const QBluetoothUuid characteristicUuid(jniUuid.toString());
++ if (characteristicUuid.isNull())
++ return;
++
++ jniUuid = jniDesc.callMethod<QtJniTypes::UUID>("getUuid");
++ const QBluetoothUuid descriptorUuid(jniUuid.toString());
++ if (descriptorUuid.isNull())
++ return;
++
++ // find matching QLEDescriptor
++ auto servicePrivate = localServices.value(serviceUuid);
++ // TODO test if service contains two characteristics with same uuid
++ // or characteristic contains two descriptors with same uuid
++ const auto handleList = servicePrivate->characteristicList.keys();
++ for (const auto charHandle: handleList) {
++ const auto &charData = servicePrivate->characteristicList.value(charHandle);
++ if (charData.uuid != characteristicUuid)
++ continue;
++
++ const auto &descHandleList = charData.descriptorList.keys();
++ for (const auto descHandle: descHandleList) {
++ const auto &descData = charData.descriptorList.value(descHandle);
++ if (descData.uuid != descriptorUuid)
++ continue;
++
++ qCDebug(QT_BT_ANDROID) << "serverDescriptorChanged: Matching descriptor"
++ << descriptorUuid << "in char" << characteristicUuid
++ << "of service" << serviceUuid;
++
++ servicePrivate->characteristicList[charHandle].descriptorList[descHandle].value = newValue;
++
++ emit servicePrivate->descriptorWritten(
++ QLowEnergyDescriptor(servicePrivate, charHandle, descHandle),
++ newValue);
++ return;
++ }
++ }
++ }
++
++ void QLowEnergyControllerPrivateAndroid::characteristicChanged(
++ int charHandle, const QByteArray &data)
++ {
++ QSharedPointer<QLowEnergyServicePrivate> service =
++ serviceForHandle(charHandle);
++ if (service.isNull())
++ return;
++
++ qCDebug(QT_BT_ANDROID) << "Characteristic change notification" << service->uuid
++ << charHandle << data.toHex() << "length:" << data.size();
++
++ QLowEnergyCharacteristic characteristic = characteristicForHandle(charHandle);
++ if (!characteristic.isValid()) {
++ qCWarning(QT_BT_ANDROID) << "characteristicChanged: Cannot find characteristic";
++ return;
++ }
++
++ // only update cache when property is readable. Otherwise it remains
++ // empty.
++ if (characteristic.properties() & QLowEnergyCharacteristic::Read)
++ updateValueOfCharacteristic(characteristic.attributeHandle(),
++ data, false);
++ emit service->characteristicChanged(characteristic, data);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::serverCharacteristicChanged(
++ const QJniObject &characteristic, const QByteArray &newValue)
++ {
++ qCDebug(QT_BT_ANDROID) << "Server characteristic change notification"
++ << newValue.toHex() << "length:" << newValue.size();
++
++ // match characteristic to servicePrivate
++ QJniObject service = characteristic.callMethod<QtJniTypes::BluetoothGattService>(
++ "getService");
++ if (!service.isValid())
++ return;
++
++ QJniObject jniUuid = service.callMethod<QtJniTypes::UUID>("getUuid");
++ QBluetoothUuid serviceUuid(jniUuid.toString());
++ if (serviceUuid.isNull())
++ return;
++
++ // TODO test if two service with same uuid exist
++ if (!localServices.contains(serviceUuid))
++ return;
++
++ auto servicePrivate = localServices.value(serviceUuid);
++
++ jniUuid = characteristic.callMethod<QtJniTypes::UUID>("getUuid");
++ QBluetoothUuid characteristicUuid(jniUuid.toString());
++ if (characteristicUuid.isNull())
++ return;
++
++ QLowEnergyHandle foundHandle = 0;
++ const auto handleList = servicePrivate->characteristicList.keys();
++ // TODO test if service contains two characteristics with same uuid
++ for (const auto handle: handleList) {
++ QLowEnergyServicePrivate::CharData &charData = servicePrivate->characteristicList[handle];
++ if (charData.uuid != characteristicUuid)
++ continue;
++
++ qCDebug(QT_BT_ANDROID) << "serverCharacteristicChanged: Matching characteristic"
++ << characteristicUuid << " on " << serviceUuid;
++ charData.value = newValue;
++ foundHandle = handle;
++ break;
++ }
++
++ if (!foundHandle)
++ return;
++
++ emit servicePrivate->characteristicChanged(
++ QLowEnergyCharacteristic(servicePrivate, foundHandle), newValue);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::serviceError(
++ int attributeHandle, QLowEnergyService::ServiceError errorCode)
++ {
++ // ignore call if it isn't really an error
++ if (errorCode == QLowEnergyService::NoError)
++ return;
++
++ QSharedPointer<QLowEnergyServicePrivate> service =
++ serviceForHandle(attributeHandle);
++ Q_ASSERT(!service.isNull());
++
++ // ATM we don't really use attributeHandle but later on we might
++ // want to associate the error code with a char or desc
++ service->setError(errorCode);
++ }
++
++ void QLowEnergyControllerPrivateAndroid::advertisementError(int errorCode)
++ {
++ Q_Q(QLowEnergyController);
++
++ switch (errorCode)
++ {
++ case 1: // AdvertiseCallback.ADVERTISE_FAILED_DATA_TOO_LARGE
++ errorString = QLowEnergyController::tr("Advertisement data is larger than 31 bytes");
++ break;
++ case 2: // AdvertiseCallback.ADVERTISE_FAILED_FEATURE_UNSUPPORTED
++ errorString = QLowEnergyController::tr("Advertisement feature not supported on the platform");
++ break;
++ case 3: // AdvertiseCallback.ADVERTISE_FAILED_INTERNAL_ERROR
++ errorString = QLowEnergyController::tr("Error occurred trying to start advertising");
++ break;
++ case 4: // AdvertiseCallback.ADVERTISE_FAILED_TOO_MANY_ADVERTISERS
++ errorString = QLowEnergyController::tr("Failed due to too many advertisers");
++ break;
++ default:
++ errorString = QLowEnergyController::tr("Unknown advertisement error");
++ break;
++ }
++
++ error = QLowEnergyController::AdvertisingError;
++ emit q->errorOccurred(error);
++
++ // not relevant states in peripheral mode
++ Q_ASSERT(state != QLowEnergyController::DiscoveredState);
++ Q_ASSERT(state != QLowEnergyController::DiscoveringState);
++
++ switch (state)
++ {
++ case QLowEnergyController::UnconnectedState:
++ case QLowEnergyController::ConnectingState:
++ case QLowEnergyController::ConnectedState:
++ case QLowEnergyController::ClosingState:
++ // noop as remote is already connected or about to disconnect.
++ // when connection drops we reset to unconnected anyway
++ break;
++
++ case QLowEnergyController::AdvertisingState:
++ setState(QLowEnergyController::UnconnectedState);
++ break;
++ default:
++ break;
++ }
++ }
++
++ static QJniObject javaParcelUuidfromQtUuid(const QBluetoothUuid &uuid)
++ {
++ QString output = uuid.toString();
++ // cut off leading and trailing brackets
++ output = output.mid(1, output.size()-2);
++
++ QJniObject javaString = QJniObject::fromString(output);
++ QJniObject parcelUuid = QJniObject::callStaticMethod<QtJniTypes::ParcelUuid>(
++ QtJniTypes::Traits<QtJniTypes::ParcelUuid>::className(), "fromString",
++ javaString.object<jstring>());
++
++ return parcelUuid;
++ }
++
++ static QJniObject createJavaAdvertiseData(const QLowEnergyAdvertisingData &data)
++ {
++ QJniObject builder = QJniObject::construct<QtJniTypes::AdvertiseDataBuilder>();
++
++ // device name cannot be set but there is choice to show it or not
++ builder = builder.callMethod<QtJniTypes::AdvertiseDataBuilder>(
++ "setIncludeDeviceName", !data.localName().isEmpty());
++ builder = builder.callMethod<QtJniTypes::AdvertiseDataBuilder>(
++ "setIncludeTxPowerLevel", data.includePowerLevel());
++ const auto services = data.services();
++ for (const auto &service : services) {
++ builder = builder.callMethod<QtJniTypes::AdvertiseDataBuilder>("addServiceUuid",
++ javaParcelUuidfromQtUuid(service).object<QtJniTypes::ParcelUuid>());
++ }
++
++ if (!data.manufacturerData().isEmpty()) {
++ QJniEnvironment env;
++ const jsize nativeSize = q26::saturate_cast<jsize>(data.manufacturerData().size());
++ jbyteArray nativeData = env->NewByteArray(nativeSize);
++ env->SetByteArrayRegion(nativeData, 0, nativeSize,
++ reinterpret_cast<const jbyte*>(data.manufacturerData().constData()));
++ builder = builder.callMethod<QtJniTypes::AdvertiseDataBuilder>(
++ "addManufacturerData", jint(data.manufacturerId()), nativeData);
++ env->DeleteLocalRef(nativeData);
++
++ if (!builder.isValid()) {
++ qCWarning(QT_BT_ANDROID) << "Cannot set manufacturer id/data";
++ }
++ }
++
++ /*// TODO Qt vs Java API mismatch
++ -> Qt assumes rawData() is a global field
++ -> Android pairs rawData() per service uuid
++ if (!data.rawData().isEmpty()) {
++ QJniEnvironment env;
++ const jsize nativeSize = q26::saturate_cast<jsize>(data.rawData().size());
++ jbyteArray nativeData = env->NewByteArray(nativeSize);
++ env->SetByteArrayRegion(nativeData, 0, nativeSize,
++ reinterpret_cast<const jbyte*>(data.rawData().constData()));
++ builder = builder.callObjectMethod("addServiceData",
++ "(Landroid/os/ParcelUuid;[B])Landroid/bluetooth/le/AdvertiseData$Builder;",
++ data.rawData().object(), nativeData);
++ env->DeleteLocalRef(nativeData);
++
++ if (env.checkAndClearExceptions()) {
++ qCWarning(QT_BT_ANDROID) << "Cannot set advertisement raw data";
++ }
++ }*/
++
++ QJniObject javaAdvertiseData = builder.callMethod<QtJniTypes::AdvertiseData>("build");
++ return javaAdvertiseData;
++ }
++
++ static QJniObject createJavaAdvertisingSetParameters(const QLowEnergyAdvertisingParameters ¶ms,
++ const QJniObject &javaObj)
++ {
++ QJniObject builder = QJniObject::construct<QtJniTypes::AdvertisingSetParametersBuilder>();
++
++ // TODO: Extended advertising support (see QTBUG-144522).
++ // We need a separate setting in the public API for it, because
++ // old BTLE devices will not be able to understand it.
++ // For now, always disable it!
++ #if 0
++ const bool supportsExtendedAdvertising =
++ javaObj.callMethod<jboolean>("isLeExtendedAdvertisingSupported");
++ builder = builder.callMethod<QtJniTypes::AdvertisingSetParametersBuilder>(
++ "setLegacyMode", !supportsExtendedAdvertising);
++ #else
++ Q_UNUSED(javaObj);
++ builder = builder.callMethod<QtJniTypes::AdvertisingSetParametersBuilder>(
++ "setLegacyMode", true);
++ #endif
++
++ bool connectable = false;
++ bool scannable = false;
++ switch (params.mode())
++ {
++ case QLowEnergyAdvertisingParameters::AdvInd:
++ connectable = true;
++ scannable = true; // TODO: if extended advertising is enabled, it must be false!
++ break;
++ case QLowEnergyAdvertisingParameters::AdvScanInd:
++ connectable = false;
++ scannable = true;
++ break;
++ case QLowEnergyAdvertisingParameters::AdvNonConnInd:
++ connectable = false;
++ scannable = false;
++ break;
++ // intentionally no default case
++ }
++ builder = builder.callMethod<QtJniTypes::AdvertisingSetParametersBuilder>(
++ "setConnectable", connectable);
++ builder = builder.callMethod<QtJniTypes::AdvertisingSetParametersBuilder>(
++ "setScannable", scannable);
++
++ // The QLowEnergyAdvertisingParameters struct contains the min and max
++ // interval values in milliseconds. However, the Android docs state
++ // the following:
++ // Bluetooth LE Advertising interval, in 0.625ms unit.
++ // Valid range is from 160 (100ms) to 16777215 (10,485.759375 s).
++ auto advertisingSetParametersObj =
++ QJniEnvironment().findClass<QtJniTypes::AdvertisingSetParameters>();
++ static const int minAdvInterval =
++ QJniObject::getStaticField<jint>(advertisingSetParametersObj, "INTERVAL_MIN");
++ static const int maxAdvInterval =
++ QJniObject::getStaticField<jint>(advertisingSetParametersObj, "INTERVAL_MAX");
++
++ int desiredInterval = (params.minimumInterval() + params.maximumInterval()) / 2 / 0.625;
++ if (desiredInterval < minAdvInterval)
++ desiredInterval = minAdvInterval;
++ else if (desiredInterval > maxAdvInterval)
++ desiredInterval = maxAdvInterval;
++
++ builder = builder.callMethod<QtJniTypes::AdvertisingSetParametersBuilder>(
++ "setInterval", desiredInterval);
++
++ QJniObject javaAdvertisingSetParameters =
++ builder.callMethod<QtJniTypes::AdvertisingSetParameters>("build");
++ return javaAdvertisingSetParameters;
++ }
++
++
++ void QLowEnergyControllerPrivateAndroid::startAdvertising(const QLowEnergyAdvertisingParameters ¶ms,
++ const QLowEnergyAdvertisingData &advertisingData,
++ const QLowEnergyAdvertisingData &scanResponseData)
++ {
++ setState(QLowEnergyController::AdvertisingState);
++
++ if (!ensureAndroidPermission(QBluetoothPermission::Access | QBluetoothPermission::Advertise)) {
++ qCWarning(QT_BT_ANDROID) << "startAdvertising() failed due to missing permissions";
++ setError(QLowEnergyController::MissingPermissionsError);
++ setState(QLowEnergyController::UnconnectedState);
++ return;
++ }
++
++ if (!hub || !hub->javaObject().isValid()) {
++ qCWarning(QT_BT_ANDROID) << "Cannot initiate QtBluetoothLEServer";
++ setError(QLowEnergyController::AdvertisingError);
++ setState(QLowEnergyController::UnconnectedState);
++ return;
++ }
++
++ // Pass on advertisingData, scanResponse & AdvertisingSetParameters
++ QJniObject jAdvertiseData = createJavaAdvertiseData(advertisingData);
++ QJniObject jScanResponse = createJavaAdvertiseData(scanResponseData);
++ QJniObject jAdvertisingSetParameters =
++ createJavaAdvertisingSetParameters(params, hub->javaObject());
++
++ const bool result = hub->javaObject().callMethod<jboolean>("startAdvertising",
++ jAdvertiseData.object<QtJniTypes::AdvertiseData>(),
++ jScanResponse.object<QtJniTypes::AdvertiseData>(),
++ jAdvertisingSetParameters.object<QtJniTypes::AdvertisingSetParameters>());
++ if (!result) {
++ setError(QLowEnergyController::AdvertisingError);
++ setState(QLowEnergyController::UnconnectedState);
++ }
++ }
++
++ void QLowEnergyControllerPrivateAndroid::stopAdvertising()
++ {
++ setState(QLowEnergyController::UnconnectedState);
++ hub->javaObject().callMethod<void>("stopAdvertising");
++ }
++
++ void QLowEnergyControllerPrivateAndroid::requestConnectionUpdate(const QLowEnergyConnectionParameters ¶ms)
++ {
++ // Android does not permit specification of specific latency or min/max
++ // connection intervals (see BluetoothGatt.requestConnectionPriority()
++ // In fact, each device manufacturer is permitted to change those values via a config
++ // file too. Therefore we can only make an approximated guess (see implementation below)
++ // In addition there is no feedback signal (known bug) from the hardware layer as per v24.
++
++ // TODO recheck in later Android releases whether callback for
++ // BluetoothGatt.requestConnectionPriority() was added
++
++ if (role != QLowEnergyController::CentralRole) {
++ qCWarning(QT_BT_ANDROID) << "On Android, connection requests only work for central role";
++ return;
++ }
++
++ const bool result = hub->javaObject().callMethod<jboolean>("requestConnectionUpdatePriority",
++ params.minimumInterval());
++ if (!result)
++ qCWarning(QT_BT_ANDROID) << "Cannot set connection update priority";
++ }
++
++ /*
++ * Returns the Java char permissions based on the given characteristic data.
++ */
++ static int setupCharPermissions(const QLowEnergyCharacteristicData &charData)
++ {
++ int permission = 0;
++ if (charData.properties() & QLowEnergyCharacteristic::Read) {
++ if (int(charData.readConstraints()) == 0 // nothing is equivalent to simple read
++ || (charData.readConstraints()
++ & QBluetooth::AttAccessConstraint::AttAuthorizationRequired)) {
++ permission |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattCharacteristic>::className(),
++ "PERMISSION_READ");
++ }
++
++ if (charData.readConstraints()
++ & QBluetooth::AttAccessConstraint::AttAuthenticationRequired) {
++ permission |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattCharacteristic>::className(),
++ "PERMISSION_READ_ENCRYPTED");
++ }
++
++ if (charData.readConstraints() & QBluetooth::AttAccessConstraint::AttEncryptionRequired) {
++ permission |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattCharacteristic>::className(),
++ "PERMISSION_READ_ENCRYPTED_MITM");
++ }
++ }
++
++ if (charData.properties() &
++ (QLowEnergyCharacteristic::Write|QLowEnergyCharacteristic::WriteNoResponse) ) {
++ if (int(charData.writeConstraints()) == 0 // no flag is equivalent ti simple write
++ || (charData.writeConstraints()
++ & QBluetooth::AttAccessConstraint::AttAuthorizationRequired)) {
++ permission |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattCharacteristic>::className(),
++ "PERMISSION_WRITE");
++ }
++
++ if (charData.writeConstraints()
++ & QBluetooth::AttAccessConstraint::AttAuthenticationRequired) {
++ permission |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattCharacteristic>::className(),
++ "PERMISSION_WRITE_ENCRYPTED");
++ }
++
++ if (charData.writeConstraints() & QBluetooth::AttAccessConstraint::AttEncryptionRequired) {
++ permission |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattCharacteristic>::className(),
++ "PERMISSION_WRITE_ENCRYPTED_MITM");
++ }
++ }
++
++ if (charData.properties() & QLowEnergyCharacteristic::WriteSigned) {
++ if (charData.writeConstraints() & QBluetooth::AttAccessConstraint::AttEncryptionRequired) {
++ permission |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattCharacteristic>::className(),
++ "PERMISSION_WRITE_SIGNED_MITM");
++ } else {
++ permission |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattCharacteristic>::className(),
++ "PERMISSION_WRITE_SIGNED");
++ }
++ }
++
++ return permission;
++ }
++
++ /*
++ * Returns the Java desc permissions based on the given descriptor data.
++ */
++ static int setupDescPermissions(const QLowEnergyDescriptorData &descData)
++ {
++ int permissions = 0;
++
++ if (descData.isReadable()) {
++ if (int(descData.readConstraints()) == 0 // empty is equivalent to simple read
++ || (descData.readConstraints()
++ & QBluetooth::AttAccessConstraint::AttAuthorizationRequired)) {
++ permissions |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattDescriptor>::className(),
++ "PERMISSION_READ");
++ }
++
++ if (descData.readConstraints()
++ & QBluetooth::AttAccessConstraint::AttAuthenticationRequired) {
++ permissions |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattDescriptor>::className(),
++ "PERMISSION_READ_ENCRYPTED");
++ }
++
++ if (descData.readConstraints() & QBluetooth::AttAccessConstraint::AttEncryptionRequired) {
++ permissions |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattDescriptor>::className(),
++ "PERMISSION_READ_ENCRYPTED_MITM");
++ }
++ }
++
++ if (descData.isWritable()) {
++ if (int(descData.readConstraints()) == 0 // empty is equivalent to simple read
++ || (descData.readConstraints()
++ & QBluetooth::AttAccessConstraint::AttAuthorizationRequired)) {
++ permissions |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattDescriptor>::className(),
++ "PERMISSION_WRITE");
++ }
++
++ if (descData.readConstraints()
++ & QBluetooth::AttAccessConstraint::AttAuthenticationRequired) {
++ permissions |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattDescriptor>::className(),
++ "PERMISSION_WRITE_ENCRYPTED");
++ }
++
++ if (descData.readConstraints() & QBluetooth::AttAccessConstraint::AttEncryptionRequired) {
++ permissions |= QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattDescriptor>::className(),
++ "PERMISSION_WRITE_ENCRYPTED_MITM");
++ }
++ }
++
++ return permissions;
++ }
++
++ void QLowEnergyControllerPrivateAndroid::addToGenericAttributeList(const QLowEnergyServiceData &serviceData,
++ QLowEnergyHandle startHandle)
++ {
++ QSharedPointer<QLowEnergyServicePrivate> service = serviceForHandle(startHandle);
++ if (service.isNull())
++ return;
++
++ // create BluetoothGattService object
++ jint sType = QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattService>::className(),
++ "SERVICE_TYPE_PRIMARY");
++ if (serviceData.type() == QLowEnergyServiceData::ServiceTypeSecondary)
++ sType = QJniObject::getStaticField<jint>(
++ QtJniTypes::Traits<QtJniTypes::BluetoothGattService>::className(),
++ "SERVICE_TYPE_SECONDARY");
++
++ service->androidService = QJniObject::construct<QtJniTypes::BluetoothGattService>(
++ javaUuidfromQtUuid(service->uuid).object<QtJniTypes::UUID>(), sType);
++
++ // add included services, which must have been added earlier already
++ const QList<QLowEnergyService*> includedServices = serviceData.includedServices();
++ for (const auto includedServiceEntry: includedServices) {
++ //TODO test this end-to-end
++ const jboolean result = service->androidService.callMethod<jboolean>("addService",
++ includedServiceEntry->d_ptr->androidService.object<QtJniTypes::BluetoothGattService>());
++ if (!result)
++ qWarning(QT_BT_ANDROID) << "Cannot add included service " << includedServiceEntry->serviceUuid()
++ << "to current service" << service->uuid;
++ }
++
++ // add characteristics
++ const QList<QLowEnergyCharacteristicData> serviceCharsData = serviceData.characteristics();
++ for (const auto &charData: serviceCharsData) {
++
++ // User may have set minimum and/or maximum characteristic value size. Enforce
++ // them here. If the user has not defined these limits, the default values 0..INT_MAX
++ // do not limit anything. If the sizes are violated here (ie. when adding the
++ // characteristics), regard it as a programming error.
++ if (charData.value().size() < charData.minimumValueLength() ||
++ charData.value().size() > charData.maximumValueLength()) {
++ qWarning() << "Warning: Ignoring characteristic" << charData.uuid()
++ << "with invalid length:" << charData.value().size()
++ << "(minimum:" << charData.minimumValueLength()
++ << "maximum:" << charData.maximumValueLength() << ").";
++ continue;
++ }
++
++ // Issue a warning if the attribute length exceeds the bluetooth standard limit.
++ if (charData.value().size() > BTLE_MAX_ATTRIBUTE_VALUE_SIZE) {
++ qCWarning(QT_BT_ANDROID) << "Warning: characteristic" << charData.uuid() << "size"
++ << "exceeds the standard: " << BTLE_MAX_ATTRIBUTE_VALUE_SIZE
++ << ", value size:" << charData.value().size();
++ }
++
++ QJniObject javaChar = QJniObject::construct<QtJniTypes::QtBtGattCharacteristic>(
++ javaUuidfromQtUuid(charData.uuid()).object<QtJniTypes::UUID>(),
++ int(charData.properties()),
++ setupCharPermissions(charData),
++ charData.minimumValueLength(),
++ charData.maximumValueLength());
++
++ QJniEnvironment env;
++ const jsize nativeCharSize = q26::saturate_cast<jsize>(charData.value().size());
++ jbyteArray jb = env->NewByteArray(nativeCharSize);
++ env->SetByteArrayRegion(jb, 0, nativeCharSize, (jbyte*)charData.value().data());
++ jboolean success = javaChar.callMethod<jboolean>("setLocalValue", jb);
++ if (!success)
++ qCWarning(QT_BT_ANDROID) << "Cannot setup initial characteristic value for " << charData.uuid();
++ env->DeleteLocalRef(jb);
++
++ const QList<QLowEnergyDescriptorData> descriptorList = charData.descriptors();
++ for (const auto &descData: descriptorList) {
++ QJniObject javaDesc = QJniObject::construct<QtJniTypes::QtBtGattDescriptor>(
++ javaUuidfromQtUuid(descData.uuid()).object<QtJniTypes::UUID>(),
++ setupDescPermissions(descData));
++
++ const jsize nativeDescSize = q26::saturate_cast<jsize>(descData.value().size());
++ jb = env->NewByteArray(nativeDescSize);
++ env->SetByteArrayRegion(jb, 0, nativeDescSize, (jbyte*)descData.value().data());
++ success = javaDesc.callMethod<jboolean>("setLocalValue", jb);
++ if (!success) {
++ qCWarning(QT_BT_ANDROID) << "Cannot setup initial descriptor value for "
++ << descData.uuid() << "(char" << charData.uuid()
++ << "on service " << service->uuid << ")";
++ }
++
++ env->DeleteLocalRef(jb);
++
++
++ success = javaChar.callMethod<jboolean>("addDescriptor",
++ javaDesc.object<QtJniTypes::BluetoothGattDescriptor>());
++ if (!success) {
++ qCWarning(QT_BT_ANDROID) << "Cannot add descriptor" << descData.uuid()
++ << "to service" << service->uuid << "(char:"
++ << charData.uuid() << ")";
++ }
++ }
++
++ success = service->androidService.callMethod<jboolean>(
++ "addCharacteristic",
++ javaChar.object<QtJniTypes::BluetoothGattCharacteristic>());
++ if (!success) {
++ qCWarning(QT_BT_ANDROID) << "Cannot add characteristic" << charData.uuid()
++ << "to service" << service->uuid;
++ }
++ }
++
++ hub->javaObject().callMethod<void>("addService",
++ service->androidService.object<QtJniTypes::BluetoothGattService>());
++ }
++
++ int QLowEnergyControllerPrivateAndroid::mtu() const
++ {
++ if (!hub) {
++ qCWarning(QT_BT_ANDROID) << "could not determine MTU, hub is does not exist";
++ return -1;
++ } else {
++ int result = hub->javaObject().callMethod<int>("mtu");
++ qCDebug(QT_BT_ANDROID) << "MTU found to be" << result;
++ return result;
++ }
++ }
++
++ void QLowEnergyControllerPrivateAndroid::readRssi()
++ {
++ if (!hub || !hub->javaObject().callMethod<jboolean>("readRemoteRssi")) {
++ qCWarning(QT_BT_ANDROID) << "request to read RSSI failed";
++ setError(QLowEnergyController::RssiReadError);
++ return;
++ }
++ }
++
++ QT_END_NAMESPACE