qlowenergycontroller.cpp

Go to the documentation of this file.

// Copyright (C) 2017 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.h"
 
#include "qlowenergycharacteristicdata.h"
#include "qlowenergyconnectionparameters.h"
#include "qlowenergydescriptordata.h"
#include "qlowenergyservicedata.h"
 
#include <QtBluetooth/QBluetoothLocalDevice>
#include <QtCore/QLoggingCategory>
 
 
#if QT_CONFIG(bluez) && !defined(QT_BLUEZ_NO_BTLE)
#include "bluez/bluez5_helper_p.h"
#include "qlowenergycontroller_bluezdbus_p.h"
#include "qlowenergycontroller_bluez_p.h"
#elif defined(QT_ANDROID_BLUETOOTH)
#include "qlowenergycontroller_android_p.h"
#include "android/androidutils_p.h"
#elif defined(QT_WINRT_BLUETOOTH)
#include "qtbluetoothglobal_p.h"
#include "qlowenergycontroller_winrt_p.h"
#elif defined(Q_OS_DARWIN)
#include "qlowenergycontroller_darwin_p.h"
#else
#include "qlowenergycontroller_dummy_p.h"
#endif
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
QT_IMPL_METATYPE_EXTERN_TAGGED(QLowEnergyController::Error, QLowEnergyController__Error)
QT_IMPL_METATYPE_EXTERN_TAGGED(QLowEnergyController::ControllerState,
                               QLowEnergyController__ControllerState)
QT_IMPL_METATYPE_EXTERN_TAGGED(QLowEnergyController::RemoteAddressType,
                               QLowEnergyController__RemoteAddressType)
QT_IMPL_METATYPE_EXTERN_TAGGED(QLowEnergyController::Role, QLowEnergyController__Role)
 
Q_DECLARE_LOGGING_CATEGORY(QT_BT)
#if defined(QT_ANDROID_BLUETOOTH)
Q_DECLARE_LOGGING_CATEGORY(QT_BT_ANDROID)
#endif
 
void registerQLowEnergyControllerMetaType()
{
    static bool initDone = false;
    if (!initDone) {
        qRegisterMetaType<QLowEnergyController::ControllerState>();
        qRegisterMetaType<QLowEnergyController::Error>();
        qRegisterMetaType<QLowEnergyConnectionParameters>();
        qRegisterMetaType<QLowEnergyCharacteristic>();
        qRegisterMetaType<QLowEnergyDescriptor>();
        initDone = true;
    }
}
 
static QLowEnergyControllerPrivate *privateController(
        QLowEnergyController::Role role,
        const QBluetoothAddress& localDevice = QBluetoothAddress{})
{
#if QT_CONFIG(bluez) && !defined(QT_BLUEZ_NO_BTLE)
    // Central role
    // The minimum Bluez DBus version for central role is 5.42, otherwise we
    // fall back to kernel ATT backend. Application can also force the choice
    // with an environment variable (see bluetoothdVersion())
    //
    // Peripheral role
    // The DBus peripheral backend is the default, and for that we check the presence of
    // the required DBus APIs and bluez version. The application may opt-out of the DBus
    // peripheral role by setting the environment variable. The fall-back is the kernel ATT
    // backend
    //
    // ### Qt 7 consider removing the non-dbus bluez (kernel ATT) support
 
    QString adapterPathWithPeripheralSupport;
    if (role == QLowEnergyController::PeripheralRole
            && bluetoothdVersion() >= QVersionNumber(5, 56)
            && !qEnvironmentVariableIsSet("QT_BLUETOOTH_USE_KERNEL_PERIPHERAL")) {
        adapterPathWithPeripheralSupport = adapterWithDBusPeripheralInterface(localDevice);
    }
 
    if (role == QLowEnergyController::CentralRole
            && bluetoothdVersion() >= QVersionNumber(5, 42)) {
        qCDebug(QT_BT) << "Using BlueZ LE DBus API for central";
        return new QLowEnergyControllerPrivateBluezDBus();
    } else if (!adapterPathWithPeripheralSupport.isEmpty()) {
        qCDebug(QT_BT) << "Using BlueZ LE DBus API for peripheral";
        return new QLowEnergyControllerPrivateBluezDBus(adapterPathWithPeripheralSupport);
    } else {
        qCDebug(QT_BT) << "Using BlueZ kernel ATT interface for"
                       << (role == QLowEnergyController::CentralRole ? "central" : "peripheral");
        return new QLowEnergyControllerPrivateBluez();
    }
#elif defined(QT_ANDROID_BLUETOOTH)
    Q_UNUSED(role);
    Q_UNUSED(localDevice);
    return new QLowEnergyControllerPrivateAndroid();
#elif defined(QT_WINRT_BLUETOOTH)
    Q_UNUSED(role);
    Q_UNUSED(localDevice);
    return new QLowEnergyControllerPrivateWinRT();
#elif defined(Q_OS_DARWIN)
    Q_UNUSED(role);
    Q_UNUSED(localDevice);
    return new QLowEnergyControllerPrivateDarwin();
#else
    Q_UNUSED(role);
    Q_UNUSED(localDevice);
    return new QLowEnergyControllerPrivateCommon();
#endif
}
 
QLowEnergyController::QLowEnergyController(
                            const QBluetoothDeviceInfo &remoteDevice,
                            const QBluetoothAddress &localDevice,
                            QObject *parent)
    : QObject(parent)
{
    d_ptr = privateController(CentralRole);
 
    Q_D(QLowEnergyController);
    d->q_ptr = this;
    d->role = CentralRole;
    d->deviceUuid = remoteDevice.deviceUuid();
    d->remoteDevice = remoteDevice.address();
 
    if (localDevice.isNull())
        d->localAdapter = QBluetoothLocalDevice().address();
    else
        d->localAdapter = localDevice;
 
    d->addressType = QLowEnergyController::PublicAddress;
    d->remoteName = remoteDevice.name();
    d->init();
}
 
QLowEnergyController *QLowEnergyController::createCentral(const QBluetoothDeviceInfo &remoteDevice,
                                                          QObject *parent)
{
    return new QLowEnergyController(remoteDevice, QBluetoothAddress(), parent);
}
 
QLowEnergyController *QLowEnergyController::createCentral(const QBluetoothDeviceInfo &remoteDevice,
                                                          const QBluetoothAddress &localDevice,
                                                          QObject *parent)
{
    return new QLowEnergyController(remoteDevice, localDevice, parent);
}
 
 
QLowEnergyController *QLowEnergyController::createPeripheral(QObject *parent)
{
    return new QLowEnergyController(QBluetoothAddress(), parent);
}
 
QLowEnergyController *QLowEnergyController::createPeripheral(const QBluetoothAddress &localDevice,
                                                             QObject *parent)
{
    return new QLowEnergyController(localDevice, parent);
}
 
QLowEnergyController::QLowEnergyController(const QBluetoothAddress &localDevice, QObject *parent)
    : QObject(parent)
{
    d_ptr = privateController(PeripheralRole, localDevice);
 
    Q_D(QLowEnergyController);
    d->q_ptr = this;
    d->role = PeripheralRole;
 
    if (localDevice.isNull())
        d->localAdapter = QBluetoothLocalDevice().address();
    else
        d->localAdapter = localDevice;
 
    d->init();
}
 
QLowEnergyController::~QLowEnergyController()
{
    disconnectFromDevice(); //in case we were connected
    delete d_ptr;
}
 
QBluetoothAddress QLowEnergyController::localAddress() const
{
    return d_ptr->localAdapter;
}
 
QBluetoothAddress QLowEnergyController::remoteAddress() const
{
    return d_ptr->remoteDevice;
}
 
QBluetoothUuid QLowEnergyController::remoteDeviceUuid() const
{
    return d_ptr->deviceUuid;
}
 
QString QLowEnergyController::remoteName() const
{
    return d_ptr->remoteName;
}
 
QLowEnergyController::ControllerState QLowEnergyController::state() const
{
    return d_ptr->state;
}
 
QLowEnergyController::RemoteAddressType QLowEnergyController::remoteAddressType() const
{
    return d_ptr->addressType;
}
 
void QLowEnergyController::setRemoteAddressType(
                    QLowEnergyController::RemoteAddressType type)
{
    d_ptr->addressType = type;
}
 
void QLowEnergyController::connectToDevice()
{
    Q_D(QLowEnergyController);
 
    if (role() != CentralRole) {
        qCWarning(QT_BT) << "Connection can only be established while in central role";
        return;
    }
 
    if (!d->isValidLocalAdapter()) {
        qCWarning(QT_BT) << "connectToDevice() LE controller has invalid adapter";
        d->setError(QLowEnergyController::InvalidBluetoothAdapterError);
        return;
    }
 
    if (state() != QLowEnergyController::UnconnectedState)
        return;
 
    d->connectToDevice();
}
 
void QLowEnergyController::disconnectFromDevice()
{
    Q_D(QLowEnergyController);
 
    if (state() == QLowEnergyController::UnconnectedState)
        return;
 
    d->invalidateServices();
    d->disconnectFromDevice();
}
 
void QLowEnergyController::discoverServices()
{
    Q_D(QLowEnergyController);
 
    if (d->role != CentralRole) {
        qCWarning(QT_BT) << "Cannot discover services in peripheral role";
        return;
    }
    if (d->state != QLowEnergyController::ConnectedState)
        return;
 
    d->setState(QLowEnergyController::DiscoveringState);
    d->discoverServices();
}
 
QList<QBluetoothUuid> QLowEnergyController::services() const
{
    return d_ptr->serviceList.keys();
}
 
QLowEnergyService *QLowEnergyController::createServiceObject(
        const QBluetoothUuid &serviceUuid, QObject *parent)
{
    Q_D(QLowEnergyController);
 
    QLowEnergyService *service = nullptr;
 
    ServiceDataMap::const_iterator it = d->serviceList.constFind(serviceUuid);
    if (it != d->serviceList.constEnd()) {
        const QSharedPointer<QLowEnergyServicePrivate> &serviceData = it.value();
 
        service = new QLowEnergyService(serviceData, parent);
    }
 
    return service;
}
 
void QLowEnergyController::startAdvertising(const QLowEnergyAdvertisingParameters &parameters,
                                            const QLowEnergyAdvertisingData &advertisingData,
                                            const QLowEnergyAdvertisingData &scanResponseData)
{
    Q_D(QLowEnergyController);
    if (role() != PeripheralRole) {
        qCWarning(QT_BT) << "Cannot start advertising in central role" << state();
        return;
    }
    if (state() != UnconnectedState) {
        qCWarning(QT_BT) << "Cannot start advertising in state" << state();
        return;
    }
    d->startAdvertising(parameters, advertisingData, scanResponseData);
}
 
void QLowEnergyController::stopAdvertising()
{
    Q_D(QLowEnergyController);
    if (state() != AdvertisingState) {
        qCDebug(QT_BT) << "stopAdvertising called in state" << state();
        return;
    }
    d->stopAdvertising();
}
 
QLowEnergyService *QLowEnergyController::addService(const QLowEnergyServiceData &service,
                                                    QObject *parent)
{
    if (role() != PeripheralRole) {
        qCWarning(QT_BT) << "Services can only be added in the peripheral role";
        return nullptr;
    }
    if (state() != UnconnectedState) {
        qCWarning(QT_BT) << "Services can only be added in unconnected state";
        return nullptr;
    }
    if (!service.isValid()) {
        qCWarning(QT_BT) << "Not adding invalid service";
        return nullptr;
    }
 
#if defined(QT_ANDROID_BLUETOOTH)
    if (!ensureAndroidPermission(QBluetoothPermission::Access)) {
        qCWarning(QT_BT_ANDROID) << "addService() failed due to missing permissions";
        return nullptr;
    }
#endif
 
    Q_D(QLowEnergyController);
    QLowEnergyService *newService = d->addServiceHelper(service);
    if (newService)
        newService->setParent(parent);
 
    return newService;
}
 
 
void QLowEnergyController::requestConnectionUpdate(const QLowEnergyConnectionParameters &parameters)
{
    switch (state()) {
    case ConnectedState:
    case DiscoveredState:
    case DiscoveringState:
        d_ptr->requestConnectionUpdate(parameters);
        break;
    default:
        qCWarning(QT_BT) << "Connection update request only possible in connected state";
    }
}
 
QLowEnergyController::Error QLowEnergyController::error() const
{
    return d_ptr->error;
}
 
QString QLowEnergyController::errorString() const
{
    return d_ptr->errorString;
}
 
QLowEnergyController::Role QLowEnergyController::role() const
{
    return d_ptr->role;
}
 
int QLowEnergyController::mtu() const
{
    return d_ptr->mtu();
}
 
void QLowEnergyController::readRssi()
{
    if (role() != CentralRole) {
        qCWarning(QT_BT, "Invalid role (peripheral), cannot read RSSI");
        return d_ptr->setError(RssiReadError); // This also emits.
    }
 
    switch (state()) {
    case UnconnectedState:
    case ConnectingState:
    case ClosingState:
        qCWarning(QT_BT, "Cannot read RSSI while not in 'Connected' state, connect first");
        return d_ptr->setError(RssiReadError); // Will emit.
    default:
        d_ptr->readRssi();
    }
}
 
QT_END_NAMESPACE
 
#include "moc_qlowenergycontroller.cpp"