qlowenergyservice.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2016 Javier S. Pedro <maemo@javispedro.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <QtCore/QCoreApplication>
#include <QtCore/QPointer>
#include <QtBluetooth/QLowEnergyService>
 
#include <algorithm>
 
#include "qlowenergycontrollerbase_p.h"
#include "qlowenergyserviceprivate_p.h"
 
#ifdef Q_OS_DARWIN
#include "qlowenergycontroller_darwin_p.h"
#endif // Q_OS_DARWIN
 
QT_BEGIN_NAMESPACE
 
QT_IMPL_METATYPE_EXTERN_TAGGED(QLowEnergyService::ServiceError, QLowEnergyService__ServiceError)
QT_IMPL_METATYPE_EXTERN_TAGGED(QLowEnergyService::ServiceState, QLowEnergyService__ServiceState)
QT_IMPL_METATYPE_EXTERN_TAGGED(QLowEnergyService::ServiceType, QLowEnergyService__ServiceType)
QT_IMPL_METATYPE_EXTERN_TAGGED(QLowEnergyService::WriteMode, QLowEnergyService__WriteMode)
 
 
QLowEnergyService::QLowEnergyService(QSharedPointer<QLowEnergyServicePrivate> p,
                                     QObject *parent)
    : QObject(parent),
      d_ptr(p)
{
    qRegisterMetaType<QLowEnergyService::ServiceState>();
    qRegisterMetaType<QLowEnergyService::ServiceError>();
    qRegisterMetaType<QLowEnergyService::ServiceType>();
    qRegisterMetaType<QLowEnergyService::WriteMode>();
 
    connect(p.data(), &QLowEnergyServicePrivate::errorOccurred, this,
            &QLowEnergyService::errorOccurred);
    connect(p.data(), &QLowEnergyServicePrivate::stateChanged,
            this, &QLowEnergyService::stateChanged);
    connect(p.data(), &QLowEnergyServicePrivate::characteristicChanged,
            this, &QLowEnergyService::characteristicChanged);
    connect(p.data(), &QLowEnergyServicePrivate::characteristicWritten,
            this, &QLowEnergyService::characteristicWritten);
    connect(p.data(), &QLowEnergyServicePrivate::descriptorWritten,
            this, &QLowEnergyService::descriptorWritten);
    connect(p.data(), &QLowEnergyServicePrivate::characteristicRead,
            this, &QLowEnergyService::characteristicRead);
    connect(p.data(), &QLowEnergyServicePrivate::descriptorRead,
            this, &QLowEnergyService::descriptorRead);
}
 
QLowEnergyService::~QLowEnergyService()
{
}
 
QList<QBluetoothUuid> QLowEnergyService::includedServices() const
{
    return d_ptr->includedServices;
}
 
QLowEnergyService::ServiceState QLowEnergyService::state() const
{
    return d_ptr->state;
}
 
QLowEnergyService::ServiceTypes QLowEnergyService::type() const
{
    return d_ptr->type;
}
 
QLowEnergyCharacteristic QLowEnergyService::characteristic(const QBluetoothUuid &uuid) const
{
    CharacteristicDataMap::const_iterator charIt = d_ptr->characteristicList.constBegin();
    for ( ; charIt != d_ptr->characteristicList.constEnd(); ++charIt) {
        const QLowEnergyHandle charHandle = charIt.key();
        const QLowEnergyServicePrivate::CharData &charDetails = charIt.value();
 
        if (charDetails.uuid == uuid)
            return QLowEnergyCharacteristic(d_ptr, charHandle);
    }
 
    return QLowEnergyCharacteristic();
}
 
QList<QLowEnergyCharacteristic> QLowEnergyService::characteristics() const
{
    QList<QLowEnergyCharacteristic> results;
    QList<QLowEnergyHandle> handles = d_ptr->characteristicList.keys();
    std::sort(handles.begin(), handles.end());
 
    for (const QLowEnergyHandle &handle : std::as_const(handles)) {
        QLowEnergyCharacteristic characteristic(d_ptr, handle);
        results.append(characteristic);
    }
    return results;
}
 
 
QBluetoothUuid QLowEnergyService::serviceUuid() const
{
    return d_ptr->uuid;
}
 
 
QString QLowEnergyService::serviceName() const
{
    bool ok = false;
    quint16 clsId = d_ptr->uuid.toUInt16(&ok);
    if (ok) {
        QBluetoothUuid::ServiceClassUuid id
                = static_cast<QBluetoothUuid::ServiceClassUuid>(clsId);
        const QString name = QBluetoothUuid::serviceClassToString(id);
        if (!name.isEmpty())
            return name;
    }
    return qApp ?
           qApp->translate("QBluetoothServiceDiscoveryAgent", "Unknown Service") :
           QStringLiteral("Unknown Service");
}
 
void QLowEnergyService::discoverDetails(DiscoveryMode mode)
{
    Q_D(QLowEnergyService);
 
    if (!d->controller || d->state == QLowEnergyService::InvalidService) {
        d->setError(QLowEnergyService::OperationError);
        return;
    }
 
    if (d->state != QLowEnergyService::RemoteService)
        return;
 
    d->setState(QLowEnergyService::RemoteServiceDiscovering);
 
    d->controller->discoverServiceDetails(d->uuid, mode);
}
 
QLowEnergyService::ServiceError QLowEnergyService::error() const
{
    return d_ptr->lastError;
}
 
bool QLowEnergyService::contains(const QLowEnergyCharacteristic &characteristic) const
{
    if (characteristic.d_ptr.isNull() || !characteristic.data)
        return false;
 
    if (d_ptr == characteristic.d_ptr
        && d_ptr->characteristicList.contains(characteristic.attributeHandle())) {
        return true;
    }
 
    return false;
}
 
 
void QLowEnergyService::readCharacteristic(
        const QLowEnergyCharacteristic &characteristic)
{
    Q_D(QLowEnergyService);
 
    if (d->controller == nullptr || state() != RemoteServiceDiscovered || !contains(characteristic)) {
        d->setError(QLowEnergyService::OperationError);
        return;
    }
 
    d->controller->readCharacteristic(characteristic.d_ptr,
                                      characteristic.attributeHandle());
}
 
void QLowEnergyService::writeCharacteristic(
        const QLowEnergyCharacteristic &characteristic,
        const QByteArray &newValue, QLowEnergyService::WriteMode mode)
{
    //TODO check behavior when writing to WriteSigned characteristic
    Q_D(QLowEnergyService);
 
    if (d->controller == nullptr
            || (d->controller->role == QLowEnergyController::CentralRole
                && state() != RemoteServiceDiscovered)
            || !contains(characteristic)) {
        d->setError(QLowEnergyService::OperationError);
        return;
    }
 
    // don't write if properties don't permit it
    d->controller->writeCharacteristic(characteristic.d_ptr,
                                       characteristic.attributeHandle(),
                                       newValue,
                                       mode);
}
 
bool QLowEnergyService::contains(const QLowEnergyDescriptor &descriptor) const
{
    if (descriptor.d_ptr.isNull() || !descriptor.data)
        return false;
 
    const QLowEnergyHandle charHandle = descriptor.characteristicHandle();
    if (!charHandle)
        return false;
 
    if (d_ptr == descriptor.d_ptr
        && d_ptr->characteristicList.contains(charHandle)
        && d_ptr->characteristicList[charHandle].descriptorList.contains(descriptor.handle()))
    {
        return true;
    }
 
    return false;
}
 
void QLowEnergyService::readDescriptor(
        const QLowEnergyDescriptor &descriptor)
{
    Q_D(QLowEnergyService);
 
    if (d->controller == nullptr || state() != RemoteServiceDiscovered || !contains(descriptor)) {
        d->setError(QLowEnergyService::OperationError);
        return;
    }
 
    d->controller->readDescriptor(descriptor.d_ptr,
                                  descriptor.characteristicHandle(),
                                  descriptor.handle());
}
 
void QLowEnergyService::writeDescriptor(const QLowEnergyDescriptor &descriptor,
                                        const QByteArray &newValue)
{
    Q_D(QLowEnergyService);
 
    if (d->controller == nullptr
            || (d->controller->role == QLowEnergyController::CentralRole
            && state() != RemoteServiceDiscovered)
        || !contains(descriptor)) {
        d->setError(QLowEnergyService::OperationError);
        return;
    }
#ifdef Q_OS_DARWIN
    if (descriptor.uuid() == QBluetoothUuid::DescriptorType::ClientCharacteristicConfiguration) {
        // We have to identify a special case - ClientCharacteristicConfiguration
        // since with CoreBluetooth:
        //
        // "You cannot use this method to write the value of a client configuration descriptor
        // (represented by the CBUUIDClientCharacteristicConfigurationString constant),
        // which describes how notification or indications are configured for a
        // characteristic’s value with respect to a client. If you want to manage
        // notifications or indications for a characteristic’s value, you must
        // use the setNotifyValue:forCharacteristic: method instead."
        auto controller = static_cast<QLowEnergyControllerPrivateDarwin *>(d->controller.data());
        return controller->setNotifyValue(descriptor.d_ptr, descriptor.characteristicHandle(), newValue);
    }
#endif // Q_OS_DARWIN
 
    d->controller->writeDescriptor(descriptor.d_ptr,
                                   descriptor.characteristicHandle(),
                                   descriptor.handle(),
                                   newValue);
}
 
QT_END_NAMESPACE
 
#include "moc_qlowenergyservice.cpp"