Comms: Add BluetoothLE Link

Author: HTRamsey

src/Comms/BluetoothLink.cc

@@ -24,7 +24,7 @@ BluetoothConfiguration::BluetoothConfiguration(const QString &name, QObject *par
     : LinkConfiguration(name, parent)
     , _deviceDiscoveryAgent(new QBluetoothDeviceDiscoveryAgent(this))
 {
-    // qCDebug(BluetoothLinkLog) << Q_FUNC_INFO << this;
+    qCDebug(BluetoothLinkLog) << this;
 
     _initDeviceDiscoveryAgent();
 }
@@ -34,7 +34,7 @@ BluetoothConfiguration::BluetoothConfiguration(const BluetoothConfiguration *cop
     , _device(copy->device())
     , _deviceDiscoveryAgent(new QBluetoothDeviceDiscoveryAgent(this))
 {
-    // qCDebug(BluetoothLinkLog) << Q_FUNC_INFO << this;
+    qCDebug(BluetoothLinkLog) << this;
 
     BluetoothConfiguration::copyFrom(copy);
 
@@ -45,45 +45,38 @@ BluetoothConfiguration::~BluetoothConfiguration()
 {
     stopScan();
 
-    // qCDebug(BluetoothLinkLog) << Q_FUNC_INFO << this;
+    qCDebug(BluetoothLinkLog) << this;
 }
 
 void BluetoothConfiguration::_initDeviceDiscoveryAgent()
 {
     (void) connect(_deviceDiscoveryAgent, &QBluetoothDeviceDiscoveryAgent::deviceDiscovered, this, &BluetoothConfiguration::_deviceDiscovered);
+    (void) connect(_deviceDiscoveryAgent, &QBluetoothDeviceDiscoveryAgent::deviceUpdated, this, &BluetoothConfiguration::_deviceUpdated);
     (void) connect(_deviceDiscoveryAgent, &QBluetoothDeviceDiscoveryAgent::canceled, this, &BluetoothConfiguration::scanningChanged);
     (void) connect(_deviceDiscoveryAgent, &QBluetoothDeviceDiscoveryAgent::finished, this, &BluetoothConfiguration::scanningChanged);
     (void) connect(_deviceDiscoveryAgent, &QBluetoothDeviceDiscoveryAgent::errorOccurred, this, &BluetoothConfiguration::_onSocketErrorOccurred);
-
-    if (BluetoothLinkLog().isDebugEnabled()) {
-        (void) connect(_deviceDiscoveryAgent, &QBluetoothDeviceDiscoveryAgent::deviceUpdated, this, [this](const QBluetoothDeviceInfo &info, QBluetoothDeviceInfo::Fields updatedFields) {
-            qCDebug(BluetoothLinkLog) << "Device Updated";
-        });
-    }
 }
 
 void BluetoothConfiguration::copyFrom(const LinkConfiguration *source)
 {
     Q_ASSERT(source);
     LinkConfiguration::copyFrom(source);
 
-    const BluetoothConfiguration *const bluetoothSource = qobject_cast<const BluetoothConfiguration*>(source);
-    Q_ASSERT(bluetoothSource);
+    const BluetoothConfiguration *config = qobject_cast<const BluetoothConfiguration*>(source);
+    Q_ASSERT(config);
 
-    _device = bluetoothSource->device();
+    _device = config->device();
     emit deviceChanged();
 }
 
 void BluetoothConfiguration::loadSettings(QSettings &settings, const QString &root)
 {
     settings.beginGroup(root);
 
-    _device.name = settings.value("deviceName", _device.name).toString();
-#ifdef Q_OS_IOS
-    _device.uuid = QUuid(settings.value("uuid", _device.uuid.toString()).toString());
-#else
-    _device.address = QBluetoothAddress(settings.value("address", _device.address.toString()).toString());
-#endif
+    const QString name = settings.value("deviceName", _device.name()).toString();
+    setDevice(name);
+    // const QBluetoothAddress address = QBluetoothAddress(settings.value("address", _device.address().toString()).toString());
+    // _device = QBluetoothDeviceInfo(address, name);
 
     settings.endGroup();
 }
@@ -92,23 +85,23 @@ void BluetoothConfiguration::saveSettings(QSettings &settings, const QString &ro
 {
     settings.beginGroup(root);
 
-    settings.setValue("deviceName", _device.name);
-#ifdef Q_OS_IOS
-    settings.setValue("uuid", _device.uuid.toString());
-#else
-    settings.setValue("address", _device.address.toString());
-#endif
+    settings.setValue("deviceName", _device.name());
+    settings.setValue("address", _device.address().toString());
 
     settings.endGroup();
 }
 
 QString BluetoothConfiguration::settingsTitle() const
 {
-    if (QGCDeviceInfo::isBluetoothAvailable()) {
-        return tr("Bluetooth Link Settings");
+    if (!QGCDeviceInfo::isBluetoothAvailable()) {
+        return tr("Bluetooth Not Available");
+    }
+
+    if (QBluetoothDeviceDiscoveryAgent::supportedDiscoveryMethods() & (QBluetoothDeviceDiscoveryAgent::ClassicMethod == 0)) {
+        return tr("Bluetooth Classic Not Supported");
     }
 
-    return tr("Bluetooth Not Available");
+    return tr("Bluetooth Link Settings");
 }
 
 void BluetoothConfiguration::startScan()
@@ -131,9 +124,9 @@ void BluetoothConfiguration::stopScan() const
 
 void BluetoothConfiguration::setDevice(const QString &name)
 {
-    for (const BluetoothData &data: _deviceList) {
-        if (data.name == name) {
-            _device = data;
+    for (const QBluetoothDeviceInfo &info: _deviceList) {
+        if (info.name() == name) {
+            _device = info;
             emit deviceChanged();
             return;
         }
@@ -147,19 +140,44 @@ bool BluetoothConfiguration::scanning() const
 
 void BluetoothConfiguration::_deviceDiscovered(const QBluetoothDeviceInfo &info)
 {
-    if (!info.name().isEmpty() && info.isValid()) {
-        BluetoothData data;
-        data.name = info.name();
-#ifdef Q_OS_IOS
-        data.uuid = info.deviceUuid();
-#else
-        data.address = info.address();
-#endif
-
-        if (!_deviceList.contains(data)) {
-            _deviceList.append(data);
-            _nameList.append(data.name);
-            emit nameListChanged();
+    if (info.name().isEmpty() || !info.isValid()) {
+        return;
+    }
+
+    if (!_deviceList.contains(info) && (info.coreConfigurations() & QBluetoothDeviceInfo::BaseRateCoreConfiguration)) {
+        _deviceList.append(info);
+        _nameList.append(info.name());
+        emit nameListChanged();
+    }
+}
+
+void BluetoothConfiguration::_deviceUpdated(const QBluetoothDeviceInfo &info, QBluetoothDeviceInfo::Fields updatedFields)
+{
+    if (!info.isValid() || (updatedFields == QBluetoothDeviceInfo::Field::None)) {
+        return;
+    }
+
+    for (QBluetoothDeviceInfo &dev: _deviceList) {
+        if (dev.address() == info.address()) {
+            if (updatedFields & QBluetoothDeviceInfo::Field::RSSI) {
+                dev.setRssi(info.rssi());
+            }
+            if (updatedFields & QBluetoothDeviceInfo::Field::ManufacturerData) {
+                const QMultiHash<quint16, QByteArray> data = info.manufacturerData();
+                for (quint16 id : info.manufacturerIds()) {
+                    dev.setManufacturerData(id, data.value(id));
+                }
+            }
+            if (updatedFields & QBluetoothDeviceInfo::Field::ServiceData) {
+                const QMultiHash<QBluetoothUuid, QByteArray> data = info.serviceData();
+                for (QBluetoothUuid uuid : info.serviceIds()) {
+                    dev.setServiceData(uuid, data.value(uuid));
+                }
+            }
+            if (updatedFields & QBluetoothDeviceInfo::Field::All) {
+                dev = info;
+            }
+            break;
         }
     }
 }
@@ -177,14 +195,14 @@ BluetoothWorker::BluetoothWorker(const BluetoothConfiguration *config, QObject *
     : QObject(parent)
     , _config(config)
 {
-    // qCDebug(BluetoothLinkLog) << Q_FUNC_INFO << this;
+    qCDebug(BluetoothLinkLog) << this;
 }
 
 BluetoothWorker::~BluetoothWorker()
 {
     disconnectLink();
 
-    // qCDebug(BluetoothLinkLog) << Q_FUNC_INFO << this;
+    qCDebug(BluetoothLinkLog) << this;
 }
 
 bool BluetoothWorker::isConnected() const
@@ -197,23 +215,11 @@ void BluetoothWorker::setupSocket()
     Q_ASSERT(!_socket);
     _socket = new QBluetoothSocket(QBluetoothServiceInfo::RfcommProtocol, this);
 
-#ifdef Q_OS_IOS
-    Q_ASSERT(!_serviceDiscoveryAgent);
-    _serviceDiscoveryAgent = new QBluetoothServiceDiscoveryAgent(this);
-#endif
-
     (void) connect(_socket, &QBluetoothSocket::connected, this, &BluetoothWorker::_onSocketConnected);
     (void) connect(_socket, &QBluetoothSocket::disconnected, this, &BluetoothWorker::_onSocketDisconnected);
     (void) connect(_socket, &QBluetoothSocket::readyRead, this, &BluetoothWorker::_onSocketReadyRead);
     (void) connect(_socket, &QBluetoothSocket::errorOccurred, this, &BluetoothWorker::_onSocketErrorOccurred);
 
-#ifdef Q_OS_IOS
-    (void) connect(_serviceDiscoveryAgent, &QBluetoothServiceDiscoveryAgent::serviceDiscovered, this, &BluetoothWorker::_serviceDiscovered);
-    (void) connect(_serviceDiscoveryAgent, &QBluetoothServiceDiscoveryAgent::finished, this, &BluetoothWorker::_discoveryFinished);
-    (void) connect(_serviceDiscoveryAgent, &QBluetoothServiceDiscoveryAgent::canceled, this, &BluetoothWorker::_discoveryFinished);
-    (void) connect(_serviceDiscoveryAgent, &QBluetoothServiceDiscoveryAgent::errorOccurred, this, &BluetoothWorker::_onServiceErrorOccurred);
-#endif
-
     if (BluetoothLinkLog().isDebugEnabled()) {
         // (void) connect(_socket, &QBluetoothSocket::bytesWritten, this, &BluetoothWorker::_onSocketBytesWritten);
 
@@ -226,36 +232,25 @@ void BluetoothWorker::setupSocket()
 void BluetoothWorker::connectLink()
 {
     if (isConnected()) {
-        qCWarning(BluetoothLinkLog) << "Already connected to" << _config->device().name;
+        qCWarning(BluetoothLinkLog) << "Already connected to" << _config->device().name();
         return;
     }
 
-    qCDebug(BluetoothLinkLog) << "Attempting to connect to" << _config->device().name;
+    qCDebug(BluetoothLinkLog) << "Attempting to connect to" << _config->device().name();
 
-#ifdef Q_OS_IOS
-    if (_serviceDiscoveryAgent && _serviceDiscoveryAgent->isActive()) {
-        _serviceDiscoveryAgent->start();
-    }
-#else
     static constexpr QBluetoothUuid uuid = QBluetoothUuid(QBluetoothUuid::ServiceClassUuid::SerialPort);
-    _socket->connectToService(_config->device().address, uuid);
-#endif
+    _socket->connectToService(_config->device().address(), uuid);
 }
 
 void BluetoothWorker::disconnectLink()
 {
     if (!isConnected()) {
-        qCWarning(BluetoothLinkLog) << "Already disconnected from device:" << _config->device().name;
+        qCWarning(BluetoothLinkLog) << "Already disconnected from device:" << _config->device().name();
         return;
     }
 
-    qCDebug(BluetoothLinkLog) << "Attempting to disconnect from device:" << _config->device().name;
+    qCDebug(BluetoothLinkLog) << "Attempting to disconnect from device:" << _config->device().name();
 
-#ifdef Q_OS_IOS
-    if (_serviceDiscoveryAgent && _serviceDiscoveryAgent->isActive()) {
-        _serviceDiscoveryAgent->stop();
-    }
-#endif
     _socket->disconnectFromService();
 }
 
@@ -295,28 +290,28 @@ void BluetoothWorker::writeData(const QByteArray &data)
 
 void BluetoothWorker::_onSocketConnected()
 {
-    qCDebug(BluetoothLinkLog) << "Socket connected to device:" << _config->device().name;
+    qCDebug(BluetoothLinkLog) << "Socket connected to device:" << _config->device().name();
     emit connected();
 }
 
 void BluetoothWorker::_onSocketDisconnected()
 {
-    qCDebug(BluetoothLinkLog) << "Socket disconnected from device:" << _config->device().name;
+    qCDebug(BluetoothLinkLog) << "Socket disconnected from device:" << _config->device().name();
     emit disconnected();
 }
 
 void BluetoothWorker::_onSocketReadyRead()
 {
     const QByteArray data = _socket->readAll();
     if (!data.isEmpty()) {
-        // qCDebug(BluetoothLinkLog) << "_onSocketReadyRead:" << data.size();
+        // qCDebug(BluetoothLinkLog) << _config->device().name() << "Read" << data.size() << "bytes";
         emit dataReceived(data);
     }
 }
 
 void BluetoothWorker::_onSocketBytesWritten(qint64 bytes)
 {
-    qCDebug(BluetoothLinkLog) << _config->device().name << "Wrote" << bytes << "bytes";
+    qCDebug(BluetoothLinkLog) << _config->device().name() << "Wrote" << bytes << "bytes";
 }
 
 void BluetoothWorker::_onSocketErrorOccurred(QBluetoothSocket::SocketError socketError)
@@ -326,38 +321,6 @@ void BluetoothWorker::_onSocketErrorOccurred(QBluetoothSocket::SocketError socke
     emit errorOccurred(errorString);
 }
 
-#ifdef Q_OS_IOS
-void BluetoothWorker::_onServiceErrorOccurred(QBluetoothServiceDiscoveryAgent::Error error)
-{
-    const QString errorString = _serviceDiscoveryAgent->errorString();
-    qCWarning(BluetoothLinkLog) << "Socket error:" << error << errorString;
-    emit errorOccurred(errorString);
-}
-
-void BluetoothWorker::_serviceDiscovered(const QBluetoothServiceInfo &info)
-{
-    if (isConnected()) {
-        qCWarning(BluetoothLinkLog) << "Already connected to" << _config->device().name;
-        return;
-    }
-
-    if (info.device().name().isEmpty() || !info.isValid()) {
-        return;
-    }
-
-    if ((_config->device().uuid == info.device().deviceUuid()) && (_config->device().name == info.device().name)) {
-        _socket->connectToService(info);
-    }
-}
-
-void BluetoothWorker::_discoveryFinished()
-{
-    if (!isConnected()) {
-        emit errorOccurred(QStringLiteral("Discovery Error: Could Not Locate Device!"));
-    }
-}
-#endif
-
 /*===========================================================================*/
 
 BluetoothLink::BluetoothLink(SharedLinkConfigurationPtr &config, QObject *parent)
@@ -366,13 +329,13 @@ BluetoothLink::BluetoothLink(SharedLinkConfigurationPtr &config, QObject *parent
     , _worker(new BluetoothWorker(_bluetoothConfig))
     , _workerThread(new QThread(this))
 {
-    // qCDebug(BluetoothLinkLog) << Q_FUNC_INFO << this;
+    qCDebug(BluetoothLinkLog) << this;
 
     _checkPermission();
 
     _workerThread->setObjectName(QStringLiteral("Bluetooth_%1").arg(_bluetoothConfig->name()));
 
-    _worker->moveToThread(_workerThread);
+    (void) _worker->moveToThread(_workerThread);
 
     (void) connect(_workerThread, &QThread::started, _worker, &BluetoothWorker::setupSocket);
     (void) connect(_workerThread, &QThread::finished, _worker, &QObject::deleteLater);
@@ -397,7 +360,7 @@ BluetoothLink::~BluetoothLink()
         qCWarning(BluetoothLinkLog) << "Failed to wait for Bluetooth Thread to close";
     }
 
-    // qCDebug(BluetoothLinkLog) << Q_FUNC_INFO << this;
+    qCDebug(BluetoothLinkLog) << this;
 }
 
 bool BluetoothLink::isConnected() const
@@ -428,7 +391,7 @@ void BluetoothLink::_onDisconnected()
 void BluetoothLink::_onErrorOccurred(const QString &errorString)
 {
     qCWarning(BluetoothLinkLog) << "Communication error:" << errorString;
-    emit communicationError(tr("Bluetooth Link Error"), tr("Link %1: (Device: %2) %3").arg(_bluetoothConfig->name(), _bluetoothConfig->device().name, errorString));
+    emit communicationError(tr("Bluetooth Link Error"), tr("Link %1: (Device: %2) %3").arg(_bluetoothConfig->name(), _bluetoothConfig->device().name(), errorString));
 }
 
 void BluetoothLink::_onDataReceived(const QByteArray &data)
@@ -441,7 +404,7 @@ void BluetoothLink::_onDataSent(const QByteArray &data)
     emit bytesSent(this, data);
 }
 
-void BluetoothLink::_writeBytes(const QByteArray& bytes)
+void BluetoothLink::_writeBytes(const QByteArray &bytes)
 {
     (void) QMetaObject::invokeMethod(_worker, "writeData", Qt::QueuedConnection, Q_ARG(QByteArray, bytes));
 }