qbluetoothservicediscoveryagent.cpp

Go to the documentation of this file.

// 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 "qbluetoothhostinfo.h"
#include "qbluetoothlocaldevice.h"
#include "qbluetoothservicediscoveryagent.h"
#include "qbluetoothservicediscoveryagent_p.h"
 
#include "qbluetoothdevicediscoveryagent.h"
 
QT_BEGIN_NAMESPACE
 
QBluetoothServiceDiscoveryAgent::QBluetoothServiceDiscoveryAgent(QObject *parent)
  : QObject(parent),
    d_ptr(new QBluetoothServiceDiscoveryAgentPrivate(this, QBluetoothAddress()))
{
}
 
QBluetoothServiceDiscoveryAgent::QBluetoothServiceDiscoveryAgent(const QBluetoothAddress &deviceAdapter, QObject *parent)
  : QObject(parent),
    d_ptr(new QBluetoothServiceDiscoveryAgentPrivate(this, deviceAdapter))
{
    if (!deviceAdapter.isNull()) {
        const QList<QBluetoothHostInfo> localDevices = QBluetoothLocalDevice::allDevices();
        for (const QBluetoothHostInfo &hostInfo : localDevices) {
            if (hostInfo.address() == deviceAdapter)
                return;
        }
        d_ptr->error = InvalidBluetoothAdapterError;
        d_ptr->errorString = tr("Invalid Bluetooth adapter address");
    }
}
 
QBluetoothServiceDiscoveryAgent::~QBluetoothServiceDiscoveryAgent()
{
    if (isActive()) {
        disconnect(); //don't emit any signals due to stop()
        stop();
    }
 
    delete d_ptr;
}
 
QList<QBluetoothServiceInfo> QBluetoothServiceDiscoveryAgent::discoveredServices() const
{
    Q_D(const QBluetoothServiceDiscoveryAgent);
 
    return d->discoveredServices;
}
void QBluetoothServiceDiscoveryAgent::setUuidFilter(const QList<QBluetoothUuid> &uuids)
{
    Q_D(QBluetoothServiceDiscoveryAgent);
 
    d->uuidFilter = uuids;
}
 
void QBluetoothServiceDiscoveryAgent::setUuidFilter(const QBluetoothUuid &uuid)
{
    Q_D(QBluetoothServiceDiscoveryAgent);
 
    d->uuidFilter.clear();
    d->uuidFilter.append(uuid);
}
 
QList<QBluetoothUuid> QBluetoothServiceDiscoveryAgent::uuidFilter() const
{
    Q_D(const QBluetoothServiceDiscoveryAgent);
 
    return d->uuidFilter;
}
 
bool QBluetoothServiceDiscoveryAgent::setRemoteAddress(const QBluetoothAddress &address)
{
    if (isActive())
        return false;
    if (!address.isNull())
        d_ptr->singleDevice = true;
    d_ptr->deviceAddress = address;
    return true;
}
 
QBluetoothAddress QBluetoothServiceDiscoveryAgent::remoteAddress() const
{
    if (d_ptr->singleDevice == true)
        return d_ptr->deviceAddress;
    else
        return QBluetoothAddress();
}
 
namespace DarwinBluetooth {
 
void qt_test_iobluetooth_runloop();
 
}
 
 
void QBluetoothServiceDiscoveryAgent::start(DiscoveryMode mode)
{
    Q_D(QBluetoothServiceDiscoveryAgent);
#ifdef QT_OSX_BLUETOOTH
    // Make sure we are on the right thread/have a run loop:
    DarwinBluetooth::qt_test_iobluetooth_runloop();
#endif
 
    if (d->discoveryState() == QBluetoothServiceDiscoveryAgentPrivate::Inactive
            && d->error != InvalidBluetoothAdapterError) {
#if QT_CONFIG(bluez)
        // done to avoid repeated parsing for adapter address
        // on Bluez5
        d->foundHostAdapterPath.clear();
#endif
        d->setDiscoveryMode(mode);
        // Clear any possible previous errors
        d->error = QBluetoothServiceDiscoveryAgent::NoError;
        d->errorString.clear();
        if (d->deviceAddress.isNull()) {
            d->startDeviceDiscovery();
        } else {
            d->discoveredDevices << QBluetoothDeviceInfo(d->deviceAddress, QString(), 0);
            d->startServiceDiscovery();
        }
    }
}
 
void QBluetoothServiceDiscoveryAgent::stop()
{
    Q_D(QBluetoothServiceDiscoveryAgent);
 
    if (d->error == InvalidBluetoothAdapterError || !isActive())
        return;
 
    switch (d->discoveryState()) {
    case QBluetoothServiceDiscoveryAgentPrivate::DeviceDiscovery:
        d->stopDeviceDiscovery();
        break;
    case QBluetoothServiceDiscoveryAgentPrivate::ServiceDiscovery:
        d->stopServiceDiscovery();
    default:
        ;
    }
 
    d->discoveredDevices.clear();
}
 
void QBluetoothServiceDiscoveryAgent::clear()
{
    Q_D(QBluetoothServiceDiscoveryAgent);
 
    //don't clear the list while the search is ongoing
    if (isActive())
        return;
 
    d->discoveredDevices.clear();
    d->discoveredServices.clear();
    d->uuidFilter.clear();
}
 
bool QBluetoothServiceDiscoveryAgent::isActive() const
{
    Q_D(const QBluetoothServiceDiscoveryAgent);
 
    return d->state != QBluetoothServiceDiscoveryAgentPrivate::Inactive;
}
 
QBluetoothServiceDiscoveryAgent::Error QBluetoothServiceDiscoveryAgent::error() const
{
    Q_D(const QBluetoothServiceDiscoveryAgent);
 
    return d->error;
}
 
QString QBluetoothServiceDiscoveryAgent::errorString() const
{
    Q_D(const QBluetoothServiceDiscoveryAgent);
    return d->errorString;
}
 
 
void QBluetoothServiceDiscoveryAgentPrivate::startDeviceDiscovery()
{
    Q_Q(QBluetoothServiceDiscoveryAgent);
 
    if (!deviceDiscoveryAgent) {
#if QT_CONFIG(bluez)
        deviceDiscoveryAgent = new QBluetoothDeviceDiscoveryAgent(m_deviceAdapterAddress, q);
#else
        deviceDiscoveryAgent = new QBluetoothDeviceDiscoveryAgent(q);
#endif
        QObject::connect(deviceDiscoveryAgent, &QBluetoothDeviceDiscoveryAgent::finished,
                         q, [this](){
            this->_q_deviceDiscoveryFinished();
        });
        QObject::connect(deviceDiscoveryAgent, &QBluetoothDeviceDiscoveryAgent::deviceDiscovered,
                         q, [this](const QBluetoothDeviceInfo &info){
            this->_q_deviceDiscovered(info);
        });
        QObject::connect(deviceDiscoveryAgent, &QBluetoothDeviceDiscoveryAgent::errorOccurred, q,
                         [this](QBluetoothDeviceDiscoveryAgent::Error newError) {
                             this->_q_deviceDiscoveryError(newError);
                         });
    }
 
    setDiscoveryState(DeviceDiscovery);
 
    deviceDiscoveryAgent->start(QBluetoothDeviceDiscoveryAgent::ClassicMethod);
}
 
void QBluetoothServiceDiscoveryAgentPrivate::stopDeviceDiscovery()
{
    // disconnect to avoid recursion during stop() - QTBUG-60131
    // we don't care about a potential signals from device discovery agent anymore
    deviceDiscoveryAgent->disconnect();
 
    deviceDiscoveryAgent->stop();
    delete deviceDiscoveryAgent;
    deviceDiscoveryAgent = nullptr;
 
    setDiscoveryState(Inactive);
 
    Q_Q(QBluetoothServiceDiscoveryAgent);
    emit q->canceled();
}
 
void QBluetoothServiceDiscoveryAgentPrivate::_q_deviceDiscoveryFinished()
{
    if (deviceDiscoveryAgent->error() != QBluetoothDeviceDiscoveryAgent::NoError) {
        //Forward the device discovery error
        error = static_cast<QBluetoothServiceDiscoveryAgent::Error>(deviceDiscoveryAgent->error());
        errorString = deviceDiscoveryAgent->errorString();
        setDiscoveryState(Inactive);
        Q_Q(QBluetoothServiceDiscoveryAgent);
        emit q->errorOccurred(error);
        emit q->finished();
        return;
    }
 
    delete deviceDiscoveryAgent;
    deviceDiscoveryAgent = nullptr;
 
    startServiceDiscovery();
}
 
void QBluetoothServiceDiscoveryAgentPrivate::_q_deviceDiscovered(const QBluetoothDeviceInfo &info)
{
    // look for duplicates, and cached entries
    const auto addressEquals = [](const auto &a) {
        return [a](const auto &info) { return info.address() == a; };
    };
    erase_if(discoveredDevices, addressEquals(info.address()));
    discoveredDevices.prepend(info);
}
 
void QBluetoothServiceDiscoveryAgentPrivate::_q_deviceDiscoveryError(QBluetoothDeviceDiscoveryAgent::Error newError)
{
    error = static_cast<QBluetoothServiceDiscoveryAgent::Error>(newError);
    errorString = deviceDiscoveryAgent->errorString();
 
    // disconnect to avoid recursion during stop() - QTBUG-60131
    // we don't care about a potential signals from device discovery agent anymore
    deviceDiscoveryAgent->disconnect();
 
    deviceDiscoveryAgent->stop();
    delete deviceDiscoveryAgent;
    deviceDiscoveryAgent = nullptr;
 
    setDiscoveryState(Inactive);
    Q_Q(QBluetoothServiceDiscoveryAgent);
    emit q->errorOccurred(error);
    emit q->finished();
}
 
void QBluetoothServiceDiscoveryAgentPrivate::startServiceDiscovery()
{
    Q_Q(QBluetoothServiceDiscoveryAgent);
 
    if (discoveredDevices.isEmpty()) {
        setDiscoveryState(Inactive);
        emit q->finished();
        return;
    }
 
    setDiscoveryState(ServiceDiscovery);
    start(discoveredDevices.at(0).address());
}
 
void QBluetoothServiceDiscoveryAgentPrivate::stopServiceDiscovery()
{
    stop();
 
    setDiscoveryState(Inactive);
}
 
void QBluetoothServiceDiscoveryAgentPrivate::_q_serviceDiscoveryFinished()
{
    if(!discoveredDevices.isEmpty()) {
        discoveredDevices.removeFirst();
    }
 
    startServiceDiscovery();
}
 
bool QBluetoothServiceDiscoveryAgentPrivate::isDuplicatedService(
        const QBluetoothServiceInfo &serviceInfo) const
{
    //check the service is not already part of our known list
    for (const QBluetoothServiceInfo &info : discoveredServices) {
        if (info.device() == serviceInfo.device()
                && info.serviceClassUuids() == serviceInfo.serviceClassUuids()
                && info.serviceUuid() == serviceInfo.serviceUuid()
                && info.serverChannel() == serviceInfo.serverChannel()) {
            return true;
        }
    }
    return false;
}
 
QT_END_NAMESPACE
 
#include "moc_qbluetoothservicediscoveryagent.cpp"