Avoid bluetoothd and QtBluetooth collision when connecting to BTLE dev

BlueZ's improving support for BTLE creates a new collision when
attenpting to connect to remote BTLE devices. There can only ever be
one connection.

This patch ensures that when QtBluetooth attempts to connect we do
not have a pending BTLE connection. This could have been caused via
other QtBLuetooth based processes or applications
such as bluetoothctl or bluetoothd in general. If a connection
is pending we close the connection external to the current QtBLuetooth
instance.

This is not an ideal situation as several processes can potentially
fight over btle access. The long term solution is a port of QtBluetooth
to BlueZ's new DBus API.

Task-number: QTBUG-55150
Change-Id: I96b30ae180d1348027e8f9f09c997f44409dfc48
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

5 files changed, 331 insertions, 3 deletions

diff --git a/src/bluetooth/bluez/bluez.pri b/src/bluetooth/bluez/bluez.pri
index 46727cbc..3ff2e9d8 100644
--- a/src/bluetooth/bluez/bluez.pri
+++ b/src/bluetooth/bluez/bluez.pri
@@ -18,7 +18,8 @@ HEADERS += bluez/manager_p.h \
            bluez/obex_objectpush1_bluez5_p.h \
            bluez/obex_transfer1_bluez5_p.h \
            bluez/bluez_data_p.h \
-           bluez/hcimanager_p.h
+           bluez/hcimanager_p.h \
+           bluez/remotedevicemanager_p.h
 
 SOURCES += bluez/manager.cpp \
            bluez/adapter.cpp \
@@ -39,4 +40,5 @@ SOURCES += bluez/manager.cpp \
            bluez/obex_client1_bluez5.cpp \
            bluez/obex_objectpush1_bluez5.cpp \
            bluez/obex_transfer1_bluez5.cpp \
-           bluez/hcimanager.cpp
+           bluez/hcimanager.cpp \
+           bluez/remotedevicemanager.cpp
diff --git a/src/bluetooth/bluez/remotedevicemanager.cpp b/src/bluetooth/bluez/remotedevicemanager.cpp
new file mode 100644
index 00000000..f63b21e6
--- /dev/null
+++ b/src/bluetooth/bluez/remotedevicemanager.cpp
@@ -0,0 +1,170 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtBluetooth module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/QLoggingCategory>
+
+#include "remotedevicemanager_p.h"
+#include "bluez5_helper_p.h"
+#include "device1_bluez5_p.h"
+#include "objectmanager_p.h"
+
+QT_BEGIN_NAMESPACE
+
+Q_DECLARE_LOGGING_CATEGORY(QT_BT_BLUEZ)
+
+/*!
+ * Convenience wrapper around org.bluez.Device1 management
+ *
+ * Very simple and not thread safe.
+ */
+
+RemoteDeviceManager::RemoteDeviceManager(
+        const QBluetoothAddress &address, QObject *parent)
+    : QObject(parent), localAddress(address)
+{
+    if (!isBluez5())
+        return;
+
+    bool ok = false;
+    adapterPath = findAdapterForAddress(address, &ok);
+    if (!ok || adapterPath.isEmpty()) {
+        qCWarning(QT_BT_BLUEZ) << "Cannot initialize RemoteDeviceManager";
+    }
+}
+
+bool RemoteDeviceManager::scheduleJob(
+        JobType job, const QVector<QBluetoothAddress> &remoteDevices)
+{
+    if (adapterPath.isEmpty())
+        return false;
+
+    for (const auto& remote : remoteDevices)
+        jobQueue.push_back(std::make_pair(job, remote));
+
+    QTimer::singleShot(0, this, [this](){ runQueue(); });
+    return true;
+}
+
+void RemoteDeviceManager::runQueue()
+{
+    if (jobInProgress || adapterPath.isEmpty())
+        return;
+
+    if (jobQueue.empty())
+        return;
+
+    jobInProgress = true;
+    switch (jobQueue.front().first) {
+    case JobType::JobDisconnectDevice:
+        disconnectDevice(jobQueue.front().second);
+        break;
+    default:
+        break;
+    }
+}
+
+void RemoteDeviceManager::prepareNextJob()
+{
+    Q_ASSERT(!jobQueue.empty());
+
+    jobQueue.pop_front();
+    jobInProgress = false;
+
+    if (jobQueue.empty())
+        emit finished();
+    else
+        runQueue();
+}
+
+void RemoteDeviceManager::disconnectDevice(const QBluetoothAddress &remote)
+{
+    // collect initial set of information
+    OrgFreedesktopDBusObjectManagerInterface managerBluez5(
+                                               QStringLiteral("org.bluez"),
+                                               QStringLiteral("/"),
+                                               QDBusConnection::systemBus(), this);
+    QDBusPendingReply<ManagedObjectList> reply = managerBluez5.GetManagedObjects();
+    reply.waitForFinished();
+    if (reply.isError()) {
+        QTimer::singleShot(0, this, [this](){ prepareNextJob(); });
+        return;
+    }
+
+    bool jobStarted = false;
+    ManagedObjectList managedObjectList = reply.value();
+    for (auto it = managedObjectList.constBegin(); it != managedObjectList.constEnd(); ++it) {
+        const QDBusObjectPath &path = it.key();
+        const InterfaceList &ifaceList = it.value();
+
+        for (auto jt = ifaceList.constBegin(); jt != ifaceList.constEnd(); ++jt) {
+            const QString &iface = jt.key();
+
+            if (path.path().indexOf(adapterPath) != 0)
+                continue; //devices whose path doesn't start with same path we skip
+
+            if (iface != QStringLiteral("org.bluez.Device1"))
+                continue;
+
+            const QBluetoothAddress foundAddress(ifaceList.value(iface).value(QStringLiteral("Address")).toString());
+            if (foundAddress != remote)
+                continue;
+
+            // found the correct Device1 path
+            OrgBluezDevice1Interface* device1 = new OrgBluezDevice1Interface(QStringLiteral("org.bluez"),
+                                                                             path.path(),
+                                                                             QDBusConnection::systemBus(),
+                                                                             this);
+            QDBusPendingReply<> asyncReply = device1->Disconnect();
+            QDBusPendingCallWatcher* watcher = new QDBusPendingCallWatcher(asyncReply, this);
+            const auto watcherFinished = [this, device1](QDBusPendingCallWatcher* call) {
+                call->deleteLater();
+                device1->deleteLater();
+                prepareNextJob();
+            };
+            connect(watcher, &QDBusPendingCallWatcher::finished, this, watcherFinished);
+            jobStarted = true;
+            break;
+        }
+    }
+
+    if (!jobStarted)
+        QTimer::singleShot(0, this, [this](){ prepareNextJob(); });
+}
+
+QT_END_NAMESPACE
diff --git a/src/bluetooth/bluez/remotedevicemanager_p.h b/src/bluetooth/bluez/remotedevicemanager_p.h
new file mode 100644
index 00000000..a6af8f44
--- /dev/null
+++ b/src/bluetooth/bluez/remotedevicemanager_p.h
@@ -0,0 +1,99 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtBluetooth module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef REMOTEDEVICEMANAGER_P_H
+#define REMOTEDEVICEMANAGER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <deque>
+
+#include <QMutex>
+#include <QObject>
+#include <QVector>
+
+#include <QtBluetooth/qbluetoothaddress.h>
+
+
+QT_BEGIN_NAMESPACE
+
+// This API is kept a bit more generic in anticipation of further changes in the future.
+
+class RemoteDeviceManager : public QObject
+{
+    Q_OBJECT
+public:
+    enum class JobType
+    {
+        JobDisconnectDevice,
+    };
+
+    explicit RemoteDeviceManager(const QBluetoothAddress& localAddress, QObject *parent = 0);
+
+    bool isJobInProgress() const { return jobInProgress; }
+    bool scheduleJob(JobType job, const QVector<QBluetoothAddress>& remoteDevices);
+
+signals:
+    void finished();
+
+private slots:
+    void runQueue();
+    void prepareNextJob();
+
+private:
+    void disconnectDevice(const QBluetoothAddress& remote);
+
+    bool jobInProgress = false;
+    QBluetoothAddress localAddress;
+    std::deque<std::pair<JobType, QBluetoothAddress>> jobQueue;
+    QString adapterPath;
+};
+
+QT_END_NAMESPACE
+
+#endif // REMOTEDEVICEMANAGER_P_H
diff --git a/src/bluetooth/qlowenergycontroller_bluez.cpp b/src/bluetooth/qlowenergycontroller_bluez.cpp
index 40744670..1649fe8c 100644
--- a/src/bluetooth/qlowenergycontroller_bluez.cpp
+++ b/src/bluetooth/qlowenergycontroller_bluez.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2017 The Qt Company Ltd.
 ** Copyright (C) 2016 Javier S. Pedro <maemo@javispedro.com>
 ** Contact: https://www.qt.io/licensing/
 **
@@ -44,6 +44,8 @@
 #include "qleadvertiser_p.h"
 #include "bluez/bluez_data_p.h"
 #include "bluez/hcimanager_p.h"
+#include "bluez/remotedevicemanager_p.h"
+#include "bluez/bluez5_helper_p.h"
 
 #include <QtCore/QFileInfo>
 #include <QtCore/QLoggingCategory>
@@ -530,13 +532,64 @@ void QLowEnergyControllerPrivate::connectToDevice()
     // check for active running connections
     // BlueZ 5.37+ (maybe even earlier versions) can have pending BTLE connections
     // Only one active L2CP socket to CID 0x4 possible at a time
+    // this check is not performed for BlueZ 4 based platforms as bluetoothd
+    // does not support BTLE management
+
+    if (!isBluez5()) {
+        establishL2cpClientSocket();
+        return;
+    }
+
     QVector<quint16> activeHandles = hciManager->activeLowEnergyConnections();
     if (!activeHandles.isEmpty()) {
         qCWarning(QT_BT_BLUEZ) << "Cannot connect due to pending active LE connections";
+
+        if (!device1Manager) {
+            device1Manager = new RemoteDeviceManager(localAdapter, this);
+            connect(device1Manager, &RemoteDeviceManager::finished,
+                    this, &QLowEnergyControllerPrivate::activeConnectionTerminationDone);
+        }
+
+        QVector<QBluetoothAddress> connectedAddresses;
+        for (const auto handle: activeHandles) {
+            const QBluetoothAddress addr = hciManager->addressForConnectionHandle(handle);
+            if (!addr.isNull())
+                connectedAddresses.push_back(addr);
+        }
+        device1Manager->scheduleJob(RemoteDeviceManager::JobType::JobDisconnectDevice, connectedAddresses);
+    } else {
+        establishL2cpClientSocket();
+    }
+}
+
+/*!
+ * Handles outcome of attempts to close external connections.
+ */
+void QLowEnergyControllerPrivate::activeConnectionTerminationDone()
+{
+    if (!device1Manager)
+        return;
+
+    qCDebug(QT_BT_BLUEZ) << "RemoteDeviceManager finished attempting"
+                         << "to close external connections";
+
+    QVector<quint16> activeHandles = hciManager->activeLowEnergyConnections();
+    if (!activeHandles.isEmpty()) {
+        qCWarning(QT_BT_BLUEZ) << "Cannot close pending external BTLE connections. Aborting connect attempt";
         setError(QLowEnergyController::ConnectionError);
         setState(QLowEnergyController::UnconnectedState);
         return;
+    } else {
+        establishL2cpClientSocket();
     }
+}
+
+/*!
+ * Establishes the L2CP client socket.
+ */
+void QLowEnergyControllerPrivate::establishL2cpClientSocket()
+{
+    //we are already in Connecting state
 
     l2cpSocket = new QBluetoothSocket(QBluetoothServiceInfo::L2capProtocol, this);
     connect(l2cpSocket, SIGNAL(connected()), this, SLOT(l2cpConnected()));
diff --git a/src/bluetooth/qlowenergycontroller_p.h b/src/bluetooth/qlowenergycontroller_p.h
index 5fcc46a4..5811376b 100644
--- a/src/bluetooth/qlowenergycontroller_p.h
+++ b/src/bluetooth/qlowenergycontroller_p.h
@@ -100,6 +100,7 @@ class QTimer;
 class HciManager;
 class LeCmacCalculator;
 class QSocketNotifier;
+class RemoteDeviceManager;
 #elif defined(QT_ANDROID_BLUETOOTH)
 class LowEnergyNotificationHub;
 #endif
@@ -279,6 +280,7 @@ private:
     QLeAdvertiser *advertiser;
     QSocketNotifier *serverSocketNotifier;
     QTimer *requestTimer = nullptr;
+    RemoteDeviceManager* device1Manager = nullptr;
 
     /*
       Defines the maximum number of milliseconds the implementation will
@@ -413,6 +415,7 @@ private:
             const QByteArray &newValue);
 
     void restartRequestTimer();
+    void establishL2cpClientSocket();
 
 private slots:
     void l2cpConnected();
@@ -421,6 +424,7 @@ private slots:
     void l2cpReadyRead();
     void encryptionChangedEvent(const QBluetoothAddress&, bool);
     void handleGattRequestTimeout();
+    void activeConnectionTerminationDone();
 #elif defined(QT_ANDROID_BLUETOOTH)
     LowEnergyNotificationHub *hub;