Merge remote-tracking branch 'origin/5.9' into dev

Change-Id: I6f1a42c6e27b262c82f87b9c90e7f346ef9ab1c7

10 files changed, 484 insertions, 3 deletions

diff --git a/dist/changes-5.9.0 b/dist/changes-5.9.0
new file mode 100644
index 00000000..2c8e162d
--- /dev/null
+++ b/dist/changes-5.9.0
@@ -0,0 +1,89 @@
+Qt 5.9 introduces many new features and improvements as well as bugfixes
+over the 5.8.x series. For more details, refer to the online documentation
+included in this distribution. The documentation is also available online:
+
+  http://doc.qt.io/qt-5/index.html
+
+The Qt version 5.9 series is binary compatible with the 5.8.x series.
+Applications compiled for 5.8 will continue to run with 5.9.
+
+Some of the changes listed in this file include issue tracking numbers
+corresponding to tasks in the Qt Bug Tracker:
+
+  https://bugreports.qt.io/
+
+Each of these identifiers can be entered in the bug tracker to obtain more
+information about a particular change.
+
+****************************************************************************
+*                          Library                                         *
+****************************************************************************
+
+QtBluetooth
+-----------
+
+ - Added various improvements to the existing Bluetooth examples.
+ - Added various documentation improvements.
+ - Added new heartrate-game example replacing the old heartlistener example.
+
+QtNfc
+-----
+
+ - Introduced QNearFieldTarget::maxCommandLength() to make it possible to
+   check the maximum supported length for commands.
+ - Introduced QNearFieldTarget::(set)keepConnection() permitting control over
+   the connection behavior. If this flag is set the NFC device does not disconnect
+   automatically after reading an NFC message. QNearFieldTarget::disconnect()
+   was added to permit manual separation of the connection. This feature is currently
+   only implemented on Android.
+
+****************************************************************************
+*                      Platform Specific Changes                           *
+****************************************************************************
+
+Android
+-------
+
+ - Added support for QNearFieldTarget::sendCommand().
+ - Fixed crash due to references leak in QBluetoothDeviceDiscoveryAgent on Android.
+ - Added more detailed GATT error reporting.
+ - [QTBUG-58085] Fixed unnecessarily dangerous right request for ACCESS_COURSE_LOCATION
+   during BTLE scanning on Android platforms below version 23.
+ - Prevented nil exception if reading of a descriptor failed during discovery.
+ - [QTBUG-58056] Fixed not reported characteristic if system failed to read its value
+   during the service discovery.
+ - [QTBUG-53483] Added support for BTLE peripheral on Android.
+ - [QTBUG-56078] Improved likelyhood that BluetoothGatt.connectGatt() succeeds. This addresses
+   the GATT_ERROR 133 (0x85) problem on Android v23+ devices. There is no fix available
+   on older Android versions.
+ - [QTBUG-57646] Fixed problems when using QtNfc when running as a service.
+ - [QTBUG-59343] Fixed crash on restart of NFC applications.
+ - [QTBUG-59455] Fixed detection of all NFC tags even non-NDEF tags.
+ - [QTBUG-59917] Added workaround for BLUETOOTH_PRIVILEGED security exception when
+   attempting to read a BTLE HID service.
+
+iOS/macOS
+---------
+
+ - Fixed missing behavior whereby QLowEnergyController::disconnectFromDevice()
+   did not stop advertisement.
+ - [QTBUG-58080] Changed priority of advertised BTLE device name. Qt prefers the
+   device name as set by the advertisement data over the GAP name.
+
+Linux/BlueZ
+-----------
+
+ - [QTBUG-52692] Prevented stalling of Linux central BTLE implementation.
+ - Fixed continued advertisement of peripheral data once
+   QLowEnergyController::disconnectFromDevice() was called. Public documentation
+   was added to publically state the behavior.
+ - [QTBUG-57417] Fixed duplicated QBluetoothLocalAdapter:deviceConnected() and
+   deviceDisconnected() signal emissions if the local device has several Bluetooth adapter.
+ - [QTBUG-59392] Ensured that pairing passkey and pincode are truly random.
+ - [QTBUG-59754] Ensured that QLowEnergyController::connected() is emitted on peripheral.
+   Previously the signal was never emitted.
+
+WinRT
+-----
+
+ - [QTBUG-37779] Added support for Classic Bluetooth on WinRT.
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/bluez_data_p.h b/src/bluetooth/bluez/bluez_data_p.h
index 8c2dc43e..25edc661 100644
--- a/src/bluetooth/bluez/bluez_data_p.h
+++ b/src/bluetooth/bluez/bluez_data_p.h
@@ -99,6 +99,10 @@ struct bt_security {
 #define BDADDR_LE_PUBLIC    0x01
 #define BDADDR_LE_RANDOM    0x02
 
+#define SCO_LINK    0x00
+#define ACL_LINK    0x01
+#define ESCO_LINK   0x02
+#define LE_LINK     0x80    // based on hcitool.c -> no fixed constant available
 
 /* Byte order conversions */
 #if __BYTE_ORDER == __LITTLE_ENDIAN
diff --git a/src/bluetooth/bluez/hcimanager.cpp b/src/bluetooth/bluez/hcimanager.cpp
index 93bf941b..c524117c 100644
--- a/src/bluetooth/bluez/hcimanager.cpp
+++ b/src/bluetooth/bluez/hcimanager.cpp
@@ -288,6 +288,50 @@ QBluetoothAddress HciManager::addressForConnectionHandle(quint16 handle) const
     return QBluetoothAddress();
 }
 
+QVector<quint16> HciManager::activeLowEnergyConnections() const
+{
+    if (!isValid())
+        return QVector<quint16>();
+
+    hci_conn_info *info;
+    hci_conn_list_req *infoList;
+
+    const int maxNoOfConnections = 20;
+    infoList = (hci_conn_list_req *)
+            malloc(sizeof(hci_conn_list_req) + maxNoOfConnections * sizeof(hci_conn_info));
+
+    if (!infoList)
+        return QVector<quint16>();
+
+    QScopedPointer<hci_conn_list_req, QScopedPointerPodDeleter> p(infoList);
+    p->conn_num = maxNoOfConnections;
+    p->dev_id = hciDev;
+    info = p->conn_info;
+
+    if (ioctl(hciSocket, HCIGETCONNLIST, (void *) infoList) < 0) {
+        qCWarning(QT_BT_BLUEZ) << "Cannot retrieve connection list";
+        return QVector<quint16>();
+    }
+
+    QVector<quint16> activeLowEnergyHandles;
+    for (int i = 0; i < infoList->conn_num; i++) {
+        switch (info[i].type) {
+        case SCO_LINK:
+        case ACL_LINK:
+        case ESCO_LINK:
+            continue;
+        case LE_LINK:
+            activeLowEnergyHandles.append(info[i].handle);
+            break;
+        default:
+            qCWarning(QT_BT_BLUEZ) << "Unknown active connection type:" << hex << info[i].type;
+            break;
+        }
+    }
+
+    return activeLowEnergyHandles;
+}
+
 quint16 forceIntervalIntoRange(double connectionInterval)
 {
     return qMin<double>(qMax<double>(7.5, connectionInterval), 4000) / 1.25;
diff --git a/src/bluetooth/bluez/hcimanager_p.h b/src/bluetooth/bluez/hcimanager_p.h
index 3bae92e5..3127a747 100644
--- a/src/bluetooth/bluez/hcimanager_p.h
+++ b/src/bluetooth/bluez/hcimanager_p.h
@@ -55,6 +55,7 @@
 #include <QtCore/QSet>
 #include <QtCore/QSocketNotifier>
 #include <QtBluetooth/QBluetoothAddress>
+#include <QVector>
 #include "bluez/bluez_data_p.h"
 
 QT_BEGIN_NAMESPACE
@@ -82,6 +83,9 @@ public:
     void stopEvents();
     QBluetoothAddress addressForConnectionHandle(quint16 handle) const;
 
+    // active connections
+    QVector<quint16> activeLowEnergyConnections() const;
+
     bool sendConnectionUpdateCommand(quint16 handle, const QLowEnergyConnectionParameters &params);
     bool sendConnectionParameterUpdateRequest(quint16 handle,
                                               const QLowEnergyConnectionParameters &params);
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/doc/qtbluetooth.qdocconf b/src/bluetooth/doc/qtbluetooth.qdocconf
index aa485cdb..a994652b 100644
--- a/src/bluetooth/doc/qtbluetooth.qdocconf
+++ b/src/bluetooth/doc/qtbluetooth.qdocconf
@@ -48,6 +48,7 @@ exampledirs += ../../../examples/bluetooth \
                ../
 
 manifestmeta.thumbnail.names = "QtBluetooth/Bluetooth Low Energy Heart Rate Server Example"
+manifestmeta.highlighted.names += "QtBluetooth/Bluetooth Low Energy Heart Rate Game"
 
 imagedirs   += images
 
diff --git a/src/bluetooth/qlowenergycontroller_bluez.cpp b/src/bluetooth/qlowenergycontroller_bluez.cpp
index 3873664a..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>
@@ -527,6 +529,68 @@ void QLowEnergyControllerPrivate::connectToDevice()
     if (l2cpSocket)
         delete l2cpSocket;
 
+    // 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()));
     connect(l2cpSocket, SIGNAL(disconnected()), this, SLOT(l2cpDisconnected()));
diff --git a/src/bluetooth/qlowenergycontroller_p.h b/src/bluetooth/qlowenergycontroller_p.h
index 1e5e038c..4b0c05cc 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;