Revision control
++ // Copyright (C) 2013 BlackBerry Limited. All rights reserved.
++ // Copyright (C) 2017 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
++
++ #include "device.h"
++
++ #include <QBluetoothDeviceInfo>
++ #include <QBluetoothUuid>
++
++ #include <QDebug>
++ #include <QMetaObject>
++ #include <QTimer>
++
++ #if QT_CONFIG(permissions)
++ #include <QPermissions>
++
++ #include <QGuiApplication>
++ #endif
++
++ using namespace Qt::StringLiterals;
++
++ Device::Device()
++ {
++ //! [les-devicediscovery-1]
++ discoveryAgent = new QBluetoothDeviceDiscoveryAgent(this);
++ discoveryAgent->setLowEnergyDiscoveryTimeout(25000);
++ connect(discoveryAgent, &QBluetoothDeviceDiscoveryAgent::deviceDiscovered,
++ this, &Device::addDevice);
++ connect(discoveryAgent, &QBluetoothDeviceDiscoveryAgent::errorOccurred,
++ this, &Device::deviceScanError);
++ connect(discoveryAgent, &QBluetoothDeviceDiscoveryAgent::finished,
++ this, &Device::deviceScanFinished);
++ connect(discoveryAgent, &QBluetoothDeviceDiscoveryAgent::canceled,
++ this, &Device::deviceScanFinished);
++ //! [les-devicediscovery-1]
++
++ setUpdate(u"Search"_s);
++ }
++
++ Device::~Device()
++ {
++ qDeleteAll(devices);
++ qDeleteAll(m_services);
++ qDeleteAll(m_characteristics);
++ devices.clear();
++ m_services.clear();
++ m_characteristics.clear();
++ }
++
++ void Device::startDeviceDiscovery()
++ {
++ qDeleteAll(devices);
++ devices.clear();
++ emit devicesUpdated();
++
++ //! [les-devicediscovery-2]
++ discoveryAgent->start(QBluetoothDeviceDiscoveryAgent::LowEnergyMethod);
++ //! [les-devicediscovery-2]
++
++ if (discoveryAgent->isActive()) {
++ setUpdate(u"Stop"_s);
++ m_deviceScanState = true;
++ Q_EMIT stateChanged();
++ }
++ }
++
++ void Device::stopDeviceDiscovery()
++ {
++ if (discoveryAgent->isActive())
++ discoveryAgent->stop();
++ }
++
++ //! [les-devicediscovery-3]
++ void Device::addDevice(const QBluetoothDeviceInfo &info)
++ {
++ if (info.coreConfigurations() & QBluetoothDeviceInfo::LowEnergyCoreConfiguration) {
++ auto devInfo = new DeviceInfo(info);
++ auto it = std::find_if(devices.begin(), devices.end(),
++ [devInfo](DeviceInfo *dev) {
++ return devInfo->getAddress() == dev->getAddress();
++ });
++ if (it == devices.end()) {
++ devices.append(devInfo);
++ } else {
++ auto oldDev = *it;
++ *it = devInfo;
++ delete oldDev;
++ }
++ emit devicesUpdated();
++ }
++ }
++ //! [les-devicediscovery-3]
++
++ void Device::deviceScanFinished()
++ {
++ m_deviceScanState = false;
++ emit stateChanged();
++ if (devices.isEmpty())
++ setUpdate(u"No Low Energy devices found..."_s);
++ else
++ setUpdate(u"Done! Scan Again!"_s);
++ }
++
++ QVariant Device::getDevices()
++ {
++ return QVariant::fromValue(devices);
++ }
++
++ QVariant Device::getServices()
++ {
++ return QVariant::fromValue(m_services);
++ }
++
++ QVariant Device::getCharacteristics()
++ {
++ return QVariant::fromValue(m_characteristics);
++ }
++
++ QString Device::getUpdate()
++ {
++ return m_message;
++ }
++
++ void Device::scanServices(const QString &address)
++ {
++ // We need the current device for service discovery.
++
++ for (auto d: std::as_const(devices)) {
++ if (auto device = qobject_cast<DeviceInfo *>(d)) {
++ if (device->getAddress() == address) {
++ currentDevice.setDevice(device->getDevice());
++ break;
++ }
++ }
++ }
++
++ if (!currentDevice.getDevice().isValid()) {
++ qWarning() << "Not a valid device";
++ return;
++ }
++
++ qDeleteAll(m_characteristics);
++ m_characteristics.clear();
++ emit characteristicsUpdated();
++ qDeleteAll(m_services);
++ m_services.clear();
++ emit servicesUpdated();
++
++ setUpdate(u"Back\n(Connecting to device...)"_s);
++
++ if (controller && m_previousAddress != currentDevice.getAddress()) {
++ controller->disconnectFromDevice();
++ delete controller;
++ controller = nullptr;
++ }
++
++ //! [les-controller-1]
++ if (!controller) {
++ // Connecting signals and slots for connecting to LE services.
++ controller = QLowEnergyController::createCentral(currentDevice.getDevice(), this);
++ connect(controller, &QLowEnergyController::connected,
++ this, &Device::deviceConnected);
++ connect(controller, &QLowEnergyController::errorOccurred, this, &Device::errorReceived);
++ connect(controller, &QLowEnergyController::disconnected,
++ this, &Device::deviceDisconnected);
++ connect(controller, &QLowEnergyController::serviceDiscovered,
++ this, &Device::addLowEnergyService);
++ connect(controller, &QLowEnergyController::discoveryFinished,
++ this, &Device::serviceScanDone);
++ }
++
++ if (isRandomAddress())
++ controller->setRemoteAddressType(QLowEnergyController::RandomAddress);
++ else
++ controller->setRemoteAddressType(QLowEnergyController::PublicAddress);
++ controller->connectToDevice();
++ //! [les-controller-1]
++
++ m_previousAddress = currentDevice.getAddress();
++ }
++
++ void Device::addLowEnergyService(const QBluetoothUuid &serviceUuid)
++ {
++ //! [les-service-1]
++ QLowEnergyService *service = controller->createServiceObject(serviceUuid);
++ if (!service) {
++ qWarning() << "Cannot create service for uuid";
++ return;
++ }
++ //! [les-service-1]
++ auto serv = new ServiceInfo(service);
++ m_services.append(serv);
++
++ emit servicesUpdated();
++ }
++ //! [les-service-1]
++
++ void Device::serviceScanDone()
++ {
++ setUpdate(u"Back\n(Service scan done!)"_s);
++ // force UI in case we didn't find anything
++ if (m_services.isEmpty())
++ emit servicesUpdated();
++ }
++
++ void Device::connectToService(const QString &uuid)
++ {
++ QLowEnergyService *service = nullptr;
++ for (auto s: std::as_const(m_services)) {
++ auto serviceInfo = qobject_cast<ServiceInfo *>(s);
++ if (!serviceInfo)
++ continue;
++
++ if (serviceInfo->getUuid() == uuid) {
++ service = serviceInfo->service();
++ break;
++ }
++ }
++
++ if (!service)
++ return;
++
++ qDeleteAll(m_characteristics);
++ m_characteristics.clear();
++ emit characteristicsUpdated();
++
++ if (service->state() == QLowEnergyService::RemoteService) {
++ //! [les-service-3]
++ connect(service, &QLowEnergyService::stateChanged,
++ this, &Device::serviceDetailsDiscovered);
++ service->discoverDetails();
++ setUpdate(u"Back\n(Discovering details...)"_s);
++ //! [les-service-3]
++ return;
++ }
++
++ //discovery already done
++ const QList<QLowEnergyCharacteristic> chars = service->characteristics();
++ for (const QLowEnergyCharacteristic &ch : chars) {
++ auto cInfo = new CharacteristicInfo(ch);
++ m_characteristics.append(cInfo);
++ }
++
++ QTimer::singleShot(0, this, &Device::characteristicsUpdated);
++ }
++
++ void Device::deviceConnected()
++ {
++ setUpdate(u"Back\n(Discovering services...)"_s);
++ connected = true;
++ //! [les-service-2]
++ controller->discoverServices();
++ //! [les-service-2]
++ }
++
++ void Device::errorReceived(QLowEnergyController::Error /*error*/)
++ {
++ qWarning() << "Error: " << controller->errorString();
++ setUpdate(u"Back\n(%1)"_s.arg(controller->errorString()));
++ }
++
++ void Device::setUpdate(const QString &message)
++ {
++ m_message = message;
++ emit updateChanged();
++ }
++
++ void Device::disconnectFromDevice()
++ {
++ // UI always expects disconnect() signal when calling this signal
++ // TODO what is really needed is to extend state() to a multi value
++ // and thus allowing UI to keep track of controller progress in addition to
++ // device scan progress
++
++ if (controller->state() != QLowEnergyController::UnconnectedState)
++ controller->disconnectFromDevice();
++ else
++ deviceDisconnected();
++ }
++
++ void Device::deviceDisconnected()
++ {
++ qWarning() << "Disconnect from device";
++ emit disconnected();
++ }
++
++ void Device::serviceDetailsDiscovered(QLowEnergyService::ServiceState newState)
++ {
++ if (newState != QLowEnergyService::RemoteServiceDiscovered) {
++ // do not hang in "Scanning for characteristics" mode forever
++ // in case the service discovery failed
++ // We have to queue the signal up to give UI time to even enter
++ // the above mode
++ if (newState != QLowEnergyService::RemoteServiceDiscovering) {
++ QMetaObject::invokeMethod(this, "characteristicsUpdated",
++ Qt::QueuedConnection);
++ }
++ return;
++ }
++
++ auto service = qobject_cast<QLowEnergyService *>(sender());
++ if (!service)
++ return;
++
++
++
++ //! [les-chars]
++ const QList<QLowEnergyCharacteristic> chars = service->characteristics();
++ for (const QLowEnergyCharacteristic &ch : chars) {
++ auto cInfo = new CharacteristicInfo(ch);
++ m_characteristics.append(cInfo);
++ }
++ //! [les-chars]
++
++ emit characteristicsUpdated();
++ }
++
++ void Device::deviceScanError(QBluetoothDeviceDiscoveryAgent::Error error)
++ {
++ if (error == QBluetoothDeviceDiscoveryAgent::PoweredOffError) {
++ setUpdate(u"The Bluetooth adaptor is powered off, power it on before doing discovery."_s);
++ } else if (error == QBluetoothDeviceDiscoveryAgent::InputOutputError) {
++ setUpdate(u"Writing or reading from the device resulted in an error."_s);
++ } else {
++ static QMetaEnum qme = discoveryAgent->metaObject()->enumerator(
++ discoveryAgent->metaObject()->indexOfEnumerator("Error"));
++ setUpdate(u"Error: "_s + QLatin1StringView(qme.valueToKey(error)));
++ }
++
++ m_deviceScanState = false;
++ emit stateChanged();
++ }
++
++ bool Device::state()
++ {
++ return m_deviceScanState;
++ }
++
++ bool Device::hasControllerError() const
++ {
++ return (controller && controller->error() != QLowEnergyController::NoError);
++ }
++
++ bool Device::isRandomAddress() const
++ {
++ return randomAddress;
++ }
++
++ void Device::setRandomAddress(bool newValue)
++ {
++ randomAddress = newValue;
++ emit randomAddressChanged();
++ }