Merge remote-tracking branch 'gerrit/dev' into wip/win

Change-Id: Ia5d83a88d6231984d9745d1c64f03553499a5882

87 files changed, 2584 insertions, 903 deletions

diff --git a/src/android/bluetooth/src/org/qtproject/qt5/android/bluetooth/QtBluetoothLE.java b/src/android/bluetooth/src/org/qtproject/qt5/android/bluetooth/QtBluetoothLE.java
index 1b527ae3..4063537b 100644
--- a/src/android/bluetooth/src/org/qtproject/qt5/android/bluetooth/QtBluetoothLE.java
+++ b/src/android/bluetooth/src/org/qtproject/qt5/android/bluetooth/QtBluetoothLE.java
@@ -1141,16 +1141,24 @@ public class QtBluetoothLE {
         if (handle == HANDLE_FOR_MTU_EXCHANGE)
             return;
 
-        GattEntry entry = entries.get(handle);
-        if (entry == null)
-            return;
-        if (entry.valueKnown)
-            return;
-        entry.valueKnown = true;
+        try {
+            synchronized (this) {
 
-        GattEntry serviceEntry = entries.get(entry.associatedServiceHandle);
-        if (serviceEntry != null && serviceEntry.endHandle == handle)
-            finishCurrentServiceDiscovery(entry.associatedServiceHandle);
+                GattEntry entry = entries.get(handle);
+                if (entry == null)
+                    return;
+                if (entry.valueKnown)
+                    return;
+                entry.valueKnown = true;
+
+                GattEntry serviceEntry = entries.get(entry.associatedServiceHandle);
+                if (serviceEntry != null && serviceEntry.endHandle == handle)
+                    finishCurrentServiceDiscovery(entry.associatedServiceHandle);
+            }
+        } catch (IndexOutOfBoundsException outOfBounds) {
+            Log.w(TAG, "interruptCurrentIO(): Unknown gatt entry, index: "
+                    + handle + " size: " + entries.size());
+        }
     }
 
     /*
@@ -1271,9 +1279,16 @@ public class QtBluetoothLE {
                     }
 
                     // last entry of current discovery run?
-                    GattEntry serviceEntry = entries.get(entry.associatedServiceHandle);
-                    if (serviceEntry.endHandle == handle)
-                        finishCurrentServiceDiscovery(entry.associatedServiceHandle);
+                    synchronized (this) {
+                        try {
+                            GattEntry serviceEntry = entries.get(entry.associatedServiceHandle);
+                            if (serviceEntry.endHandle == handle)
+                                finishCurrentServiceDiscovery(entry.associatedServiceHandle);
+                        } catch (IndexOutOfBoundsException outOfBounds) {
+                            Log.w(TAG, "performNextIO(): Unknown service for entry, index: "
+                                            + entry.associatedServiceHandle + " size: " + entries.size());
+                        }
+                    }
                 } else {
                     int errorCode = 0;
 
diff --git a/src/android/bluetooth/src/org/qtproject/qt5/android/bluetooth/QtBluetoothLEServer.java b/src/android/bluetooth/src/org/qtproject/qt5/android/bluetooth/QtBluetoothLEServer.java
index 00217904..cdd16686 100644
--- a/src/android/bluetooth/src/org/qtproject/qt5/android/bluetooth/QtBluetoothLEServer.java
+++ b/src/android/bluetooth/src/org/qtproject/qt5/android/bluetooth/QtBluetoothLEServer.java
@@ -82,6 +82,12 @@ public class QtBluetoothLEServer {
     private BluetoothGattServer mGattServer = null;
     private BluetoothLeAdvertiser mLeAdvertiser = null;
 
+    private String mRemoteName = "";
+    public String remoteName() { return mRemoteName; }
+
+    private String mRemoteAddress = "";
+    public String remoteAddress() { return mRemoteAddress; }
+
     /*
         As per Bluetooth specification each connected device can have individual and persistent
         Client characteristic configurations (see Bluetooth Spec 5.0 Vol 3 Part G 3.3.3.3)
@@ -207,7 +213,6 @@ public class QtBluetoothLEServer {
             return;
         }
 
-        mGattServer = manager.openGattServer(qtContext, mGattServerListener);
         mLeAdvertiser = mBluetoothAdapter.getBluetoothLeAdvertiser();
 
         if (!mBluetoothAdapter.isMultipleAdvertisementSupported())
@@ -223,7 +228,7 @@ public class QtBluetoothLEServer {
     {
         @Override
         public void onConnectionStateChange(BluetoothDevice device, int status, int newState) {
-            Log.w(TAG, "Our gatt server connection state changed, new state: " + newState);
+            Log.w(TAG, "Our gatt server connection state changed, new state: " + newState + " " + status);
             super.onConnectionStateChange(device, status, newState);
 
             int qtControllerState = 0;
@@ -231,6 +236,7 @@ public class QtBluetoothLEServer {
                 case BluetoothProfile.STATE_DISCONNECTED:
                     qtControllerState = 0; // QLowEnergyController::UnconnectedState
                     clientCharacteristicManager.markDeviceConnectivity(device, false);
+                    mGattServer.close();
                     break;
                 case BluetoothProfile.STATE_CONNECTED:
                     clientCharacteristicManager.markDeviceConnectivity(device, true);
@@ -238,6 +244,9 @@ public class QtBluetoothLEServer {
                     break;
             }
 
+            mRemoteName = device.getName();
+            mRemoteAddress = device.getAddress();
+
             int qtErrorCode;
             switch (status) {
                 case BluetoothGatt.GATT_SUCCESS:
@@ -392,10 +401,18 @@ public class QtBluetoothLEServer {
 
     public boolean connectServer()
     {
-        if (mGattServer == null)
+        if (mGattServer != null)
+            return true;
+
+        BluetoothManager manager = (BluetoothManager) qtContext.getSystemService(Context.BLUETOOTH_SERVICE);
+        if (manager == null) {
+            Log.w(TAG, "Bluetooth service not available.");
             return false;
+        }
 
-        return true;
+        mGattServer = manager.openGattServer(qtContext, mGattServerListener);
+
+        return (mGattServer != null);
     }
 
     public void disconnectServer()
@@ -404,6 +421,10 @@ public class QtBluetoothLEServer {
             return;
 
         mGattServer.close();
+        mGattServer = null;
+
+        mRemoteName = mRemoteAddress = "";
+        leServerConnectionStateChange(qtObject, 0 /*NoError*/, 0 /*QLowEnergyController::UnconnectedState*/);
     }
 
     public boolean startAdvertising(AdvertiseData advertiseData,
@@ -413,7 +434,10 @@ public class QtBluetoothLEServer {
         if (mLeAdvertiser == null)
             return false;
 
-        connectServer();
+        if (!connectServer()) {
+            Log.w(TAG, "Server::startAdvertising: Cannot open GATT server");
+            return false;
+        }
 
         Log.w(TAG, "Starting to advertise.");
         mLeAdvertiser.startAdvertising(settings, advertiseData, scanResponse, mAdvertiseListener);
@@ -432,8 +456,10 @@ public class QtBluetoothLEServer {
 
     public void addService(BluetoothGattService service)
     {
-        if (mGattServer == null)
+        if (!connectServer()) {
+            Log.w(TAG, "Server::addService: Cannot open GATT server");
             return;
+        }
 
         mGattServer.addService(service);
     }
diff --git a/src/android/nfc/nfc.pro b/src/android/nfc/nfc.pro
index 89026b75..a725fb7d 100644
--- a/src/android/nfc/nfc.pro
+++ b/src/android/nfc/nfc.pro
@@ -7,7 +7,8 @@ PATHPREFIX = $$PWD/src/org/qtproject/qt5/android/nfc
 
 JAVACLASSPATH += $$PWD/src/
 JAVASOURCES += \
-    $$PWD/src/org/qtproject/qt5/android/nfc/QtNfc.java
+    $$PWD/src/org/qtproject/qt5/android/nfc/QtNfc.java \
+    $$PWD/src/org/qtproject/qt5/android/nfc/QtNfcBroadcastReceiver.java \
 
 # install
 target.path = $$[QT_INSTALL_PREFIX]/jar
diff --git a/src/android/nfc/src/org/qtproject/qt5/android/nfc/QtNfc.java b/src/android/nfc/src/org/qtproject/qt5/android/nfc/QtNfc.java
index 345b87d3..6b0fbcbd 100644
--- a/src/android/nfc/src/org/qtproject/qt5/android/nfc/QtNfc.java
+++ b/src/android/nfc/src/org/qtproject/qt5/android/nfc/QtNfc.java
@@ -169,6 +169,11 @@ public class QtNfc
         return m_adapter.isEnabled();
     }
 
+    static public boolean isSupported()
+    {
+        return (m_adapter != null);
+    }
+
     static public Intent getStartIntent()
     {
         Log.d(TAG, "getStartIntent");
diff --git a/src/android/nfc/src/org/qtproject/qt5/android/nfc/QtNfcBroadcastReceiver.java b/src/android/nfc/src/org/qtproject/qt5/android/nfc/QtNfcBroadcastReceiver.java
new file mode 100644
index 00000000..ea650ede
--- /dev/null
+++ b/src/android/nfc/src/org/qtproject/qt5/android/nfc/QtNfcBroadcastReceiver.java
@@ -0,0 +1,72 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 Governikus GmbH & Co. KG
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtNfc 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$
+**
+****************************************************************************/
+
+package org.qtproject.qt5.android.nfc;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.nfc.NfcAdapter;
+
+
+public class QtNfcBroadcastReceiver extends BroadcastReceiver
+{
+    private Context qtContext;
+
+    public QtNfcBroadcastReceiver(Context context)
+    {
+        qtContext = context;
+        IntentFilter filter = new IntentFilter(NfcAdapter.ACTION_ADAPTER_STATE_CHANGED);
+        qtContext.registerReceiver(this, filter);
+    }
+
+    public void unregisterReceiver()
+    {
+        qtContext.unregisterReceiver(this);
+    }
+
+    public void onReceive(Context context, Intent intent)
+    {
+        final int state = intent.getIntExtra(NfcAdapter.EXTRA_ADAPTER_STATE, NfcAdapter.STATE_OFF);
+        jniOnReceive(state);
+    }
+
+    public native void jniOnReceive(int state);
+}
diff --git a/src/bluetooth/android/inputstreamthread.cpp b/src/bluetooth/android/inputstreamthread.cpp
index 982c477b..1cc353a3 100644
--- a/src/bluetooth/android/inputstreamthread.cpp
+++ b/src/bluetooth/android/inputstreamthread.cpp
@@ -42,13 +42,13 @@
 #include <QtAndroidExtras/QAndroidJniEnvironment>
 
 #include "android/inputstreamthread_p.h"
-#include "qbluetoothsocket_p.h"
+#include "qbluetoothsocket_android_p.h"
 
 QT_BEGIN_NAMESPACE
 
 Q_DECLARE_LOGGING_CATEGORY(QT_BT_ANDROID)
 
-InputStreamThread::InputStreamThread(QBluetoothSocketPrivate *socket)
+InputStreamThread::InputStreamThread(QBluetoothSocketPrivateAndroid *socket)
     : QObject(), m_socket_p(socket), expectClosure(false)
 {
 }
diff --git a/src/bluetooth/android/inputstreamthread_p.h b/src/bluetooth/android/inputstreamthread_p.h
index a6ee0655..060b2acf 100644
--- a/src/bluetooth/android/inputstreamthread_p.h
+++ b/src/bluetooth/android/inputstreamthread_p.h
@@ -59,13 +59,13 @@
 
 QT_BEGIN_NAMESPACE
 
-class QBluetoothSocketPrivate;
+class QBluetoothSocketPrivateAndroid;
 
 class InputStreamThread : public QObject
 {
     Q_OBJECT
 public:
-    explicit InputStreamThread(QBluetoothSocketPrivate *socket_p);
+    explicit InputStreamThread(QBluetoothSocketPrivateAndroid *socket_p);
 
     qint64 bytesAvailable() const;
     bool canReadLine() const;
@@ -82,7 +82,7 @@ signals:
     void error(int errorCode);
 
 private:
-    QBluetoothSocketPrivate *m_socket_p;
+    QBluetoothSocketPrivateAndroid *m_socket_p;
     QAndroidJniObject javaInputStreamThread;
     mutable QMutex m_mutex;
     bool expectClosure;
diff --git a/src/bluetooth/bluetooth.pro b/src/bluetooth/bluetooth.pro
index b6aa4f9f..c82b052b 100644
--- a/src/bluetooth/bluetooth.pro
+++ b/src/bluetooth/bluetooth.pro
@@ -40,7 +40,7 @@ PRIVATE_HEADERS += \
     qbluetoothserviceinfo_p.h\
     qbluetoothdevicediscoveryagent_p.h\
     qbluetoothservicediscoveryagent_p.h\
-    qbluetoothsocket_p.h\
+    qbluetoothsocketbase_p.h \
     qbluetoothserver_p.h\
     qbluetoothtransferreply_p.h \
     qbluetoothtransferrequest_p.h \
@@ -60,6 +60,7 @@ SOURCES += \
     qbluetoothdevicediscoveryagent.cpp\
     qbluetoothservicediscoveryagent.cpp\
     qbluetoothsocket.cpp\
+    qbluetoothsocketbase.cpp \
     qbluetoothserver.cpp \
     qbluetoothlocaldevice.cpp \
     qbluetooth.cpp \
@@ -94,16 +95,19 @@ qtConfig(bluez) {
     include(bluez/bluez.pri)
 
     PRIVATE_HEADERS += \
-        qbluetoothtransferreply_bluez_p.h
+        qbluetoothtransferreply_bluez_p.h \
+        qbluetoothsocket_bluez_p.h \
+        qbluetoothsocket_bluezdbus_p.h
 
     SOURCES += \
         qbluetoothserviceinfo_bluez.cpp \
         qbluetoothdevicediscoveryagent_bluez.cpp\
         qbluetoothservicediscoveryagent_bluez.cpp \
         qbluetoothsocket_bluez.cpp \
+        qbluetoothsocket_bluezdbus.cpp \
         qbluetoothserver_bluez.cpp \
         qbluetoothlocaldevice_bluez.cpp \
-        qbluetoothtransferreply_bluez.cpp \
+        qbluetoothtransferreply_bluez.cpp
 
 
     # old versions of Bluez do not have the required BTLE symbols
@@ -148,8 +152,8 @@ qtConfig(bluez) {
         qbluetoothserver_android.cpp \
         qlowenergycontroller_android.cpp
 
-    PRIVATE_HEADERS += qlowenergycontroller_android_p.h
-
+    PRIVATE_HEADERS += qlowenergycontroller_android_p.h \
+                       qbluetoothsocket_android_p.h
 } else:osx {
     QT_PRIVATE = concurrent
     DEFINES += QT_OSX_BLUETOOTH
@@ -177,6 +181,7 @@ qtConfig(bluez) {
     SOURCES -= qbluetoothserviceinfo.cpp
     SOURCES -= qbluetoothservicediscoveryagent.cpp
     SOURCES -= qbluetoothsocket.cpp
+    SOURCES -= qbluetoothsocketbase.cpp
     SOURCES -= qbluetoothserver.cpp
     SOURCES -= qlowenergyservice_p.cpp
     SOURCES -= qlowenergyservice.cpp
@@ -192,14 +197,15 @@ qtConfig(bluez) {
         qlowenergyservice_osx.mm
 
     PRIVATE_HEADERS += \
-        qlowenergycontroller_osx_p.h
+        qlowenergycontroller_osx_p.h \
+        qbluetoothsocket_dummy_p.h
 
     include(osx/osxbt.pri)
     SOURCES += \
         qbluetoothlocaldevice_p.cpp \
         qbluetoothserviceinfo_p.cpp \
         qbluetoothservicediscoveryagent_p.cpp \
-        qbluetoothsocket_p.cpp \
+        qbluetoothsocket_dummy.cpp \
         qbluetoothserver_p.cpp
 
     SOURCES -= qbluetoothdevicediscoveryagent.cpp
@@ -225,7 +231,8 @@ qtConfig(bluez) {
         qbluetoothsocket_winrt.cpp \
         qlowenergycontroller_winrt.cpp
 
-    PRIVATE_HEADERS += qlowenergycontroller_winrt_p.h
+    PRIVATE_HEADERS += qlowenergycontroller_winrt_p.h \
+                       qbluetoothsocket_winrt_p.h
 
     lessThan(WINDOWS_SDK_VERSION, 14393) {
         DEFINES += QT_WINRT_LIMITED_SERVICEDISCOVERY
@@ -261,11 +268,12 @@ qtConfig(bluez) {
         qbluetoothlocaldevice_p.cpp \
         qbluetoothserviceinfo_p.cpp \
         qbluetoothservicediscoveryagent_p.cpp \
-        qbluetoothsocket_p.cpp \
+        qbluetoothsocket_dummy.cpp \
         qbluetoothserver_p.cpp \
         qlowenergycontroller_p.cpp
 
-    PRIVATE_HEADERS += qlowenergycontroller_p.h
+    PRIVATE_HEADERS += qlowenergycontroller_p.h \
+                       qbluetoothsocket_dummy_p.h
 }
 
 winrt {
diff --git a/src/bluetooth/bluez/bluetoothmanagement.cpp b/src/bluetooth/bluez/bluetoothmanagement.cpp
index 9df74b34..3f97f75c 100644
--- a/src/bluetooth/bluez/bluetoothmanagement.cpp
+++ b/src/bluetooth/bluez/bluetoothmanagement.cpp
@@ -43,7 +43,7 @@
 
 #include "bluetoothmanagement_p.h"
 #include "bluez_data_p.h"
-#include "../qbluetoothsocket_p.h"
+#include "../qbluetoothsocketbase_p.h"
 
 #include <unistd.h>
 #include <sys/prctl.h>
diff --git a/src/bluetooth/bluez/bluez5_helper.cpp b/src/bluetooth/bluez/bluez5_helper.cpp
index 90b7e5e0..f798088e 100644
--- a/src/bluetooth/bluez/bluez5_helper.cpp
+++ b/src/bluetooth/bluez/bluez5_helper.cpp
@@ -197,8 +197,9 @@ QVersionNumber bluetoothdVersion()
     if (bluezDaemonVersion()->isNull()) {
         qCDebug(QT_BT_BLUEZ) << "Detecting bluetoothd version";
         //Order of matching
-        // 1. Pick whatever the user decides via BLUETOOTH_USE_BLUEZ_DBUS_LE
-        const QString version = qEnvironmentVariable("BLUETOOTH_USE_BLUEZ_DBUS_LE");
+        // 1. Pick whatever the user decides via BLUETOOTH_FORCE_DBUS_LE_VERSION
+        // Set version to below version 5.42 to use custom/old GATT stack implementation
+        const QString version = qEnvironmentVariable("BLUETOOTH_FORCE_DBUS_LE_VERSION");
         if (!version.isNull()) {
             const QVersionNumber vn = QVersionNumber::fromString(version);
             if (!vn.isNull()) {
diff --git a/src/bluetooth/bluez/generate b/src/bluetooth/bluez/generate
index caae92f6..5c401ffe 100755
--- a/src/bluetooth/bluez/generate
+++ b/src/bluetooth/bluez/generate
@@ -13,9 +13,9 @@ qdbusxml2cpp -a obex_agent_p.h:obex_agent.cpp org.openobex.agent.xml org.openobe
 
 #Bluez 5
 qdbusxml2cpp -p adapter1_bluez5_p.h:adapter1_bluez5.cpp org.bluez.Adapter1.xml
-qdbusxml2cpp -p device1_bluez5_p.h:device1_bluez5.cpp org.bluez.Device1.xml
+qdbusxml2cpp -i bluez5_helper_p.h -p device1_bluez5_p.h:device1_bluez5.cpp org.bluez.Device1.xml
 qdbusxml2cpp -p profile1_p.h:profile1.cpp org.bluez.ProfileManager1.xml
-qdbusxml2cpp -p objectmanager_p.h:objectmanager.cpp org.freedesktop.dbus.objectmanager.xml
+qdbusxml2cpp -i bluez5_helper_p.h -p objectmanager_p.h:objectmanager.cpp org.freedesktop.dbus.objectmanager.xml
 qdbusxml2cpp -p properties_p.h:properties.cpp org.freedesktop.dbus.properties.xml
 qdbusxml2cpp -p obex_client1_bluez5_p.h:obex_client1_bluez5_p.h org.bluez.Client1.xml
 qdbusxml2cpp -p obex_objectpush1_bluez5_p.h:obex_objectpush1_bluez5.cpp org.bluez.obex.ObjectPush1.xml
diff --git a/src/bluetooth/bluez/hcimanager.cpp b/src/bluetooth/bluez/hcimanager.cpp
index be62c881..bdb74ae0 100644
--- a/src/bluetooth/bluez/hcimanager.cpp
+++ b/src/bluetooth/bluez/hcimanager.cpp
@@ -40,7 +40,7 @@
 
 #include "hcimanager_p.h"
 
-#include "qbluetoothsocket_p.h"
+#include "qbluetoothsocketbase_p.h"
 #include "qlowenergyconnectionparameters.h"
 
 #include <QtCore/qloggingcategory.h>
diff --git a/src/bluetooth/doc/src/bluetooth-index.qdoc b/src/bluetooth/doc/src/bluetooth-index.qdoc
index 9cb5f3b2..2a4f72bc 100644
--- a/src/bluetooth/doc/src/bluetooth-index.qdoc
+++ b/src/bluetooth/doc/src/bluetooth-index.qdoc
@@ -43,7 +43,7 @@ Currently, the API is supported on the following platforms:
     \li \l {Qt for Linux/X11}{Linux (BlueZ 4.x/5.x)}
     \li \l {Qt for OS X}{macOS}
     \li \l {Qt for WinRT}{WinRT}
-    \li \l {Qt for Windows}{Windows}
+    \li \l {Qt for Windows}{Win32}
 \row
     \li Classic Bluetooth
     \li x
@@ -78,6 +78,11 @@ Currently, the API is supported on the following platforms:
     \li
 \endtable
 
+Despite there not being a Win32 port yet, the WinRT backend is automatically used
+if the win32 target platform supports the required WinRT APIs. Minimal requirement is Windows 10 version 1507
+with slightly improved service discovery since Windows 10 version 1607. Therefore Windows 7 and 8.x
+targets are excluded.
+
 \section1 Overview
 
 Bluetooth is a short-range (less than 100 meters) wireless technology. It
diff --git a/src/bluetooth/doc/src/bluetooth-qml.qdoc b/src/bluetooth/doc/src/bluetooth-qml.qdoc
index 51aa5a25..2f37cb9b 100644
--- a/src/bluetooth/doc/src/bluetooth-qml.qdoc
+++ b/src/bluetooth/doc/src/bluetooth-qml.qdoc
@@ -28,7 +28,7 @@
 
 /*!
 
-\qmlmodule QtBluetooth 5.2
+\qmlmodule QtBluetooth 5.11
 \title Qt Bluetooth QML Types
 \ingroup qmlmodules
 \brief Provides QML types for basic Bluetooth operations on devices.
diff --git a/src/bluetooth/osx/osxbt.pri b/src/bluetooth/osx/osxbt.pri
index 0f293107..b7ac0535 100644
--- a/src/bluetooth/osx/osxbt.pri
+++ b/src/bluetooth/osx/osxbt.pri
@@ -1,5 +1,8 @@
 SOURCES += osx/uistrings.cpp osx/osxbtnotifier.cpp
-PRIVATE_HEADERS += osx/uistrings_p.h
+PRIVATE_HEADERS += osx/uistrings_p.h \
+                   osx/osxbtgcdtimer_p.h
+
+OBJECTIVE_SOURCES += osx/osxbtgcdtimer.mm
 #QMAKE_CXXFLAGS_WARN_ON += -Wno-nullability-completeness
 
 CONFIG(osx) {
diff --git a/src/bluetooth/osx/osxbtcentralmanager.mm b/src/bluetooth/osx/osxbtcentralmanager.mm
index 78e6b832..9254bd98 100644
--- a/src/bluetooth/osx/osxbtcentralmanager.mm
+++ b/src/bluetooth/osx/osxbtcentralmanager.mm
@@ -79,8 +79,21 @@ NSUInteger qt_countGATTEntries(CBService *service)
     return n;
 }
 
+ObjCStrongReference<NSError> qt_timeoutNSError(OperationTimeout type)
+{
+    // For now we do not provide details, since nobody is using this NSError
+    // after all (except callbacks checking if an operation was successful
+    // or not).
+    Q_ASSERT(type != OperationTimeout::none);
+    Q_UNUSED(type)
+    NSError *nsError = [[NSError alloc] initWithDomain:CBErrorDomain
+                                        code:CBErrorOperationCancelled
+                                        userInfo:nil];
+    return ObjCStrongReference<NSError>(nsError, false /*do not retain, done already*/);
 }
 
+} // namespace OSXBluetooth
+
 QT_END_NAMESPACE
 
 
@@ -115,9 +128,11 @@ QT_END_NAMESPACE
 
 - (id)initWith:(OSXBluetooth::LECBManagerNotifier *)aNotifier
 {
+    using namespace OSXBluetooth;
+
     if (self = [super init]) {
         manager = nil;
-        managerState = OSXBluetooth::CentralManagerIdle;
+        managerState = CentralManagerIdle;
         disconnectPending = false;
         peripheral = nil;
         notifier = aNotifier;
@@ -125,6 +140,17 @@ QT_END_NAMESPACE
         lastValidHandle = 0;
         requestPending = false;
         currentReadHandle = 0;
+        timeoutType = OperationTimeout::none;
+
+        if (Q_UNLIKELY(!qEnvironmentVariableIsEmpty("BLUETOOTH_GATT_TIMEOUT"))) {
+            bool ok = false;
+            const int value = qEnvironmentVariableIntValue("BLUETOOTH_GATT_TIMEOUT", &ok);
+            if (ok && value >= 0)
+                timeoutMS = value;
+        }
+
+        if (!timeoutMS)
+            timeoutMS = 20000;
     }
 
     return self;
@@ -153,6 +179,63 @@ QT_END_NAMESPACE
     [super dealloc];
 }
 
+- (void)watchAfter:(id)object timeout:(OSXBluetooth::OperationTimeout)type
+{
+    using namespace OSXBluetooth;
+
+    objectUnderWatch = object;
+    timeoutType = type;
+    [timeoutWatchdog cancelTimer];
+    timeoutWatchdog.reset([[GCDTimerObjC alloc] initWithDelegate:self]);
+    [timeoutWatchdog startWithTimeout:timeoutMS step:200];
+}
+
+- (void)stopWatchdog
+{
+    [timeoutWatchdog cancelTimer];
+    objectUnderWatch = nil;
+    timeoutType = OSXBluetooth::OperationTimeout::none;
+}
+
+- (void)timeout
+{
+    using namespace OSXBluetooth;
+
+    Q_ASSERT(objectUnderWatch);
+    NSLog(@"Timeout caused by: %@", objectUnderWatch);
+    const ObjCStrongReference<NSError> nsError(qt_timeoutNSError(timeoutType));
+    switch (timeoutType) {
+    case OperationTimeout::serviceDiscovery:
+        qCWarning(QT_BT_OSX, "Timeout in services discovery");
+        [self peripheral:peripheral didDiscoverServices:nsError];
+        break;
+    case OperationTimeout::includedServicesDiscovery:
+        qCWarning(QT_BT_OSX, "Timeout in included services discovery");
+        [self peripheral:peripheral didDiscoverIncludedServicesForService:objectUnderWatch error:nsError];
+        break;
+    case OperationTimeout::characteristicsDiscovery:
+        qCWarning(QT_BT_OSX, "Timeout in characteristics discovery");
+        [self peripheral:peripheral didDiscoverCharacteristicsForService:objectUnderWatch error:nsError];
+        break;
+    case OperationTimeout::characteristicRead:
+        qCWarning(QT_BT_OSX, "Timeout while reading a characteristic");
+        [self peripheral:peripheral didUpdateValueForCharacteristic:objectUnderWatch error:nsError];
+        break;
+    case OperationTimeout::descriptorsDiscovery:
+        qCWarning(QT_BT_OSX, "Timeout in descriptors discovery");
+        [self peripheral:peripheral didDiscoverDescriptorsForCharacteristic:objectUnderWatch error:nsError];
+        break;
+    case OperationTimeout::descriptorRead:
+        qCWarning(QT_BT_OSX, "Timeout while reading a descriptor");
+        [self peripheral:peripheral didUpdateValueForDescriptor:objectUnderWatch error:nsError];
+        break;
+    case OperationTimeout::characteristicWrite:
+        qCWarning(QT_BT_OSX, "Timeout while writing a characteristic with response");
+        [self peripheral:peripheral didWriteValueForCharacteristic:objectUnderWatch error:nsError];
+    default:;
+    }
+}
+
 - (void)connectToDevice:(const QBluetoothUuid &)aDeviceUuid
 {
     disconnectPending = false; // Cancel the previous disconnect if any.
@@ -235,10 +318,11 @@ QT_END_NAMESPACE
 
 - (void)connectToPeripheral
 {
+    using namespace OSXBluetooth;
+
     Q_ASSERT_X(manager, Q_FUNC_INFO, "invalid central manager (nil)");
     Q_ASSERT_X(peripheral, Q_FUNC_INFO, "invalid peripheral (nil)");
-    Q_ASSERT_X(managerState == OSXBluetooth::CentralManagerIdle,
-               Q_FUNC_INFO, "invalid state");
+    Q_ASSERT_X(managerState == CentralManagerIdle, Q_FUNC_INFO, "invalid state");
 
     // The state is still the same - connecting.
     if ([self isConnected]) {
@@ -247,7 +331,7 @@ QT_END_NAMESPACE
             emit notifier->connected();
     } else {
         qCDebug(QT_BT_OSX) << "trying to connect";
-        managerState = OSXBluetooth::CentralManagerConnecting;
+        managerState = CentralManagerConnecting;
         [manager connectPeripheral:peripheral options:nil];
     }
 }
@@ -292,9 +376,10 @@ QT_END_NAMESPACE
 
 - (void)discoverServices
 {
+    using namespace OSXBluetooth;
+
     Q_ASSERT_X(peripheral, Q_FUNC_INFO, "invalid peripheral (nil)");
-    Q_ASSERT_X(managerState == OSXBluetooth::CentralManagerIdle,
-               Q_FUNC_INFO, "invalid state");
+    Q_ASSERT_X(managerState == CentralManagerIdle, Q_FUNC_INFO, "invalid state");
 
     // From Apple's docs:
     //
@@ -304,7 +389,8 @@ QT_END_NAMESPACE
     //
     // ... but we'd like to have them all:
     [peripheral setDelegate:self];
-    managerState = OSXBluetooth::CentralManagerDiscovering;
+    managerState = CentralManagerDiscovering;
+    [self watchAfter:peripheral timeout:OperationTimeout::serviceDiscovery];
     [peripheral discoverServices:nil];
 }
 
@@ -333,6 +419,7 @@ QT_END_NAMESPACE
         CBService *const s = [services objectAtIndex:currentService];
         [visitedServices addObject:s];
         managerState = CentralManagerDiscovering;
+        [self watchAfter:s timeout:OperationTimeout::includedServicesDiscovery];
         [peripheral discoverIncludedServices:nil forService:s];
     }
 }
@@ -359,6 +446,7 @@ QT_END_NAMESPACE
 
     if (CBService *const service = [self serviceForUUID:serviceUuid]) {
         servicesToDiscoverDetails.append(serviceUuid);
+        [self watchAfter:service timeout:OperationTimeout::characteristicsDiscovery];
         [peripheral discoverCharacteristics:nil forService:service];
         return;
     }
@@ -366,10 +454,8 @@ QT_END_NAMESPACE
     qCWarning(QT_BT_OSX) << "unknown service uuid"
                          << serviceUuid;
 
-    if (notifier) {
-        emit notifier->CBManagerError(serviceUuid,
-                       QLowEnergyService::UnknownError);
-    }
+    if (notifier)
+        emit notifier->CBManagerError(serviceUuid, QLowEnergyService::UnknownError);
 }
 
 - (void)readCharacteristics:(CBService *)service
@@ -391,8 +477,10 @@ QT_END_NAMESPACE
 
     NSArray *const cs = service.characteristics;
     for (CBCharacteristic *c in cs) {
-        if (c.properties & CBCharacteristicPropertyRead)
+        if (c.properties & CBCharacteristicPropertyRead) {
+            [self watchAfter:c timeout:OperationTimeout::characteristicRead];
             return [peripheral readValueForCharacteristic:c];
+        }
     }
 
     // No readable properties? Discover descriptors then:
@@ -418,15 +506,18 @@ QT_END_NAMESPACE
         [self serviceDetailsDiscoveryFinished:service];
     } else {
         // Start from 0 and continue in the callback.
-        [peripheral discoverDescriptorsForCharacteristic:[service.characteristics objectAtIndex:0]];
+        CBCharacteristic *ch = [service.characteristics objectAtIndex:0];
+        [self watchAfter:ch timeout:OperationTimeout::descriptorsDiscovery];
+        [peripheral discoverDescriptorsForCharacteristic:ch];
     }
 }
 
 - (void)readDescriptors:(CBService *)service
 {
+    using namespace OSXBluetooth;
+
     Q_ASSERT_X(service, Q_FUNC_INFO, "invalid service (nil)");
-    Q_ASSERT_X(managerState != OSXBluetooth::CentralManagerUpdating,
-               Q_FUNC_INFO, "invalid state");
+    Q_ASSERT_X(managerState != CentralManagerUpdating, Q_FUNC_INFO, "invalid state");
     Q_ASSERT_X(peripheral, Q_FUNC_INFO, "invalid peripheral (nil)");
 
     QT_BT_MAC_AUTORELEASEPOOL;
@@ -435,8 +526,11 @@ QT_END_NAMESPACE
     // We can never be here if we have no characteristics.
     Q_ASSERT_X(cs && cs.count, Q_FUNC_INFO, "invalid service");
     for (CBCharacteristic *c in cs) {
-        if (c.descriptors && c.descriptors.count)
-            return [peripheral readValueForDescriptor:[c.descriptors objectAtIndex:0]];
+        if (c.descriptors && c.descriptors.count) {
+            CBDescriptor *desc = [c.descriptors objectAtIndex:0];
+            [self watchAfter:desc timeout:OperationTimeout::descriptorRead];
+            return [peripheral readValueForDescriptor:desc];
+        }
     }
 
     // No descriptors to read, done.
@@ -571,6 +665,8 @@ QT_END_NAMESPACE
 
         requestPending = true;
         currentReadHandle = request.handle;
+        // Timeouts: for now, we do not alert timeoutWatchdog - never had such
+        // bug reports and after all a read timeout can be handled externally.
         [peripheral readValueForCharacteristic:charMap[request.handle]];
     } else {
         if (!descMap.contains(request.handle)) {
@@ -581,6 +677,7 @@ QT_END_NAMESPACE
 
         requestPending = true;
         currentReadHandle = request.handle;
+        // Timeouts: see the comment above (CharRead).
         [peripheral readValueForDescriptor:descMap[request.handle]];
     }
 }
@@ -657,6 +754,7 @@ QT_END_NAMESPACE
                     return [self performNextRequest];
 
                 requestPending = true;
+                [self watchAfter:characteristic timeout:OperationTimeout::characteristicWrite];
                 [peripheral writeValue:data.data() forCharacteristic:characteristic
                             type:CBCharacteristicWriteWithResponse];
             } else {
@@ -1021,6 +1119,7 @@ QT_END_NAMESPACE
     charMap.clear();
     descMap.clear();
     currentReadHandle = 0;
+    [self stopWatchdog];
     // TODO: also serviceToVisit/VisitNext and visitedServices ?
 }
 
@@ -1075,12 +1174,14 @@ QT_END_NAMESPACE
 #else
     if (state == CBCentralManagerStatePoweredOff) {
 #endif
-        managerState = CentralManagerIdle;
+
         if (managerState == CentralManagerUpdating) {
+            managerState = CentralManagerIdle;
             // I've seen this instead of Unsupported on OS X.
             if (notifier)
                 emit notifier->LEnotSupported();
         } else {
+            managerState = CentralManagerIdle;
             // TODO: we need a better error +
             // what will happen if later the state changes to PoweredOn???
             if (notifier)
@@ -1167,10 +1268,16 @@ QT_END_NAMESPACE
     Q_UNUSED(aPeripheral)
 
     if (managerState != OSXBluetooth::CentralManagerDiscovering) {
-        // Canceled by -disconnectFromDevice.
+        // Canceled by -disconnectFromDevice, or as a result of a timeout.
+        return;
+    }
+
+    if (objectUnderWatch != aPeripheral) {
+        // Timed out.
         return;
     }
 
+    [self stopWatchdog];
     managerState = OSXBluetooth::CentralManagerIdle;
 
     if (error) {
@@ -1178,9 +1285,9 @@ QT_END_NAMESPACE
         // TODO: better error mapping required.
         if (notifier)
             emit notifier->CBManagerError(QLowEnergyController::UnknownError);
-    } else {
-        [self discoverIncludedServices];
     }
+
+    [self discoverIncludedServices];
 }
 
 
@@ -1196,10 +1303,16 @@ QT_END_NAMESPACE
         return;
     }
 
+    if (service != objectUnderWatch) {
+        // Timed out.
+        return;
+    }
+
     QT_BT_MAC_AUTORELEASEPOOL;
 
     Q_ASSERT_X(peripheral, Q_FUNC_INFO, "invalid peripheral (nil)");
 
+    [self stopWatchdog];
     managerState = CentralManagerIdle;
 
     if (error) {
@@ -1222,6 +1335,7 @@ QT_END_NAMESPACE
             // Continue with discovery ...
             [visitedServices addObject:s];
             managerState = CentralManagerDiscovering;
+            [self watchAfter:s timeout:OperationTimeout::includedServicesDiscovery];
             return [peripheral discoverIncludedServices:nil forService:s];
         }
     }
@@ -1237,6 +1351,7 @@ QT_END_NAMESPACE
             if (![visitedServices containsObject:s]) {
                 [visitedServices addObject:s];
                 managerState = CentralManagerDiscovering;
+                [self watchAfter:s timeout:OperationTimeout::includedServicesDiscovery];
                 return [peripheral discoverIncludedServices:nil forService:s];
             }
         }
@@ -1265,6 +1380,13 @@ QT_END_NAMESPACE
         return;
     }
 
+    if (service != objectUnderWatch) {
+        // Timed out already?
+        return;
+    }
+
+    [self stopWatchdog];
+
     using namespace OSXBluetooth;
 
     Q_ASSERT_X(managerState != CentralManagerUpdating, Q_FUNC_INFO, "invalid state");
@@ -1274,9 +1396,9 @@ QT_END_NAMESPACE
         // We did not discover any characteristics and can not discover descriptors,
         // inform our delegate (it will set a service state also).
         emit notifier->CBManagerError(qt_uuid(service.UUID), QLowEnergyController::UnknownError);
-    } else {
-        [self readCharacteristics:service];
     }
+
+    [self readCharacteristics:service];
 }
 
 - (void)peripheral:(CBPeripheral *)aPeripheral
@@ -1290,6 +1412,10 @@ QT_END_NAMESPACE
         return;
     }
 
+    const bool readMatch = characteristic == objectUnderWatch;
+    if (readMatch)
+        [self stopWatchdog];
+
     using namespace OSXBluetooth;
 
     Q_ASSERT_X(managerState != CentralManagerUpdating, Q_FUNC_INFO, "invalid state");
@@ -1316,13 +1442,17 @@ QT_END_NAMESPACE
     }
 
     if (isDetailsDiscovery) {
-        // Test if we have any other characteristic to read yet.
-        CBCharacteristic *const next = [self nextCharacteristicForService:characteristic.service
-                                             startingFrom:characteristic properties:CBCharacteristicPropertyRead];
-        if (next)
-            [peripheral readValueForCharacteristic:next];
-        else
-            [self discoverDescriptors:characteristic.service];
+        if (readMatch) {
+            // Test if we have any other characteristic to read yet.
+            CBCharacteristic *const next = [self nextCharacteristicForService:characteristic.service
+                                                 startingFrom:characteristic properties:CBCharacteristicPropertyRead];
+            if (next) {
+                [self watchAfter:next timeout:OperationTimeout::characteristicRead];
+                [peripheral readValueForCharacteristic:next];
+            } else {
+                [self discoverDescriptors:characteristic.service];
+            }
+        }
     } else {
         // This is (probably) the result of update notification.
         // It's very possible we can have an invalid handle here (0) -
@@ -1365,6 +1495,11 @@ QT_END_NAMESPACE
 
     QT_BT_MAC_AUTORELEASEPOOL;
 
+    if (characteristic != objectUnderWatch)
+        return;
+
+    [self stopWatchdog];
+
     using namespace OSXBluetooth;
 
     if (error) {
@@ -1375,10 +1510,12 @@ QT_END_NAMESPACE
     // Do we have more characteristics on this service to discover descriptors?
     CBCharacteristic *const next = [self nextCharacteristicForService:characteristic.service
                                          startingFrom:characteristic];
-    if (next)
+    if (next) {
+        [self watchAfter:next timeout:OperationTimeout::descriptorsDiscovery];
         [peripheral discoverDescriptorsForCharacteristic:next];
-    else
+    } else {
         [self readDescriptors:characteristic.service];
+    }
 }
 
 - (void)peripheral:(CBPeripheral *)aPeripheral
@@ -1396,6 +1533,11 @@ QT_END_NAMESPACE
 
     QT_BT_MAC_AUTORELEASEPOOL;
 
+    if (descriptor != objectUnderWatch)
+        return;
+
+    [self stopWatchdog];
+
     using namespace OSXBluetooth;
 
     CBService *const service = descriptor.characteristic.service;
@@ -1422,6 +1564,7 @@ QT_END_NAMESPACE
         CBDescriptor *const next = [self nextDescriptorForCharacteristic:descriptor.characteristic
                                          startingFrom:descriptor];
         if (next) {
+            [self watchAfter:next timeout:OperationTimeout::descriptorRead];
             [peripheral readValueForDescriptor:next];
         } else {
             // We either have to read a value for a next descriptor
@@ -1431,8 +1574,11 @@ QT_END_NAMESPACE
             CBCharacteristic *nextCh = [self nextCharacteristicForService:ch.service
                                              startingFrom:ch];
             while (nextCh) {
-                if (nextCh.descriptors && nextCh.descriptors.count)
-                    return [peripheral readValueForDescriptor:[nextCh.descriptors objectAtIndex:0]];
+                if (nextCh.descriptors && nextCh.descriptors.count) {
+                    CBDescriptor *desc = [nextCh.descriptors objectAtIndex:0];
+                    [self watchAfter:desc timeout:OperationTimeout::descriptorRead];
+                    return [peripheral readValueForDescriptor:desc];
+                }
 
                 nextCh = [self nextCharacteristicForService:ch.service
                                startingFrom:nextCh];
@@ -1479,6 +1625,10 @@ QT_END_NAMESPACE
 
     QT_BT_MAC_AUTORELEASEPOOL;
 
+    if (characteristic != objectUnderWatch)
+        return;
+
+    [self stopWatchdog];
     requestPending = false;
 
 
@@ -1574,9 +1724,10 @@ QT_END_NAMESPACE
     if (notifier) {
         notifier->disconnect();
         notifier->deleteLater();
-        notifier = 0;
+        notifier = nullptr;
     }
 
+    [self stopWatchdog];
     [self disconnectFromDevice];
 }
 
diff --git a/src/bluetooth/osx/osxbtcentralmanager_p.h b/src/bluetooth/osx/osxbtcentralmanager_p.h
index 697d922c..e172d874 100644
--- a/src/bluetooth/osx/osxbtcentralmanager_p.h
+++ b/src/bluetooth/osx/osxbtcentralmanager_p.h
@@ -53,6 +53,7 @@
 
 #include "qlowenergycontroller.h"
 #include "qlowenergyservice.h"
+#include "osxbtgcdtimer_p.h"
 #include "qbluetoothuuid.h"
 #include "osxbtutility_p.h"
 #include "osxbluetooth_p.h"
@@ -86,6 +87,18 @@ enum CentralManagerState
     CentralManagerDisconnecting
 };
 
+enum class OperationTimeout
+{
+    none,
+    serviceDiscovery,
+    includedServicesDiscovery,
+    characteristicsDiscovery,
+    characteristicRead,
+    descriptorsDiscovery,
+    descriptorRead,
+    characteristicWrite
+};
+
 // In Qt we work with handles and UUIDs. Core Bluetooth
 // has NSArrays (and nested NSArrays inside servces/characteristics).
 // To simplify a navigation, I need a simple way to map from a handle
@@ -132,7 +145,9 @@ typedef QHash<NSObject *, QByteArray> ValueHash;
 
 QT_END_NAMESPACE
 
-@interface QT_MANGLE_NAMESPACE(OSXBTCentralManager) : NSObject<CBCentralManagerDelegate, CBPeripheralDelegate>
+@interface QT_MANGLE_NAMESPACE(OSXBTCentralManager) : NSObject<CBCentralManagerDelegate,
+                                                               CBPeripheralDelegate,
+                                                               QT_MANGLE_NAMESPACE(GCDTimerDelegate)>
 {
 @private
     CBCentralManager *manager;
@@ -166,6 +181,12 @@ QT_END_NAMESPACE
     QT_PREPEND_NAMESPACE(QLowEnergyHandle) currentReadHandle;
 
     QT_PREPEND_NAMESPACE(OSXBluetooth)::ValueHash valuesToWrite;
+
+    qint64 timeoutMS;
+    id objectUnderWatch;
+    QT_PREPEND_NAMESPACE(OSXBluetooth)::OperationTimeout timeoutType;
+    QT_PREPEND_NAMESPACE(OSXBluetooth)::GCDTimer timeoutWatchdog;
+
 @public
     CBPeripheral *peripheral;
 }
diff --git a/src/bluetooth/osx/osxbtgcdtimer.mm b/src/bluetooth/osx/osxbtgcdtimer.mm
new file mode 100644
index 00000000..095f8680
--- /dev/null
+++ b/src/bluetooth/osx/osxbtgcdtimer.mm
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 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 "osxbtgcdtimer_p.h"
+#include "osxbtutility_p.h"
+
+#include <QtCore/qdebug.h>
+
+#include <algorithm>
+
+@implementation QT_MANGLE_NAMESPACE(OSXBTGCDTimer)
+
+- (instancetype)initWithDelegate:(id<QT_MANGLE_NAMESPACE(GCDTimerDelegate)>)delegate
+{
+    if (self = [super init]) {
+        timeoutHandler = delegate;
+        timeoutMS = 0;
+        timeoutStepMS = 0;
+        cancelled = false;
+    }
+    return self;
+}
+
+- (void)startWithTimeout:(qint64)ms step:(qint64)stepMS
+{
+    Q_ASSERT(!timeoutMS && !timeoutStepMS);
+    Q_ASSERT(!cancelled);
+
+    if (!timeoutHandler) {
+        // Nobody to report timeout to, no need to start any task then.
+        return;
+    }
+
+    if (ms <= 0 || stepMS <= 0) {
+        qCWarning(QT_BT_OSX, "Invalid timeout/step parameters");
+        return;
+    }
+
+    timeoutMS = ms;
+    timeoutStepMS = stepMS;
+    timer.start();
+
+    [self handleTimeout];
+}
+
+- (void)handleTimeout
+{
+    if (cancelled)
+        return;
+
+    const qint64 elapsed = timer.elapsed();
+    if (elapsed >= timeoutMS) {
+        [timeoutHandler timeout];
+    } else {
+        using namespace QT_PREPEND_NAMESPACE(OSXBluetooth);
+        // Re-schedule:
+        dispatch_queue_t leQueue(qt_LE_queue());
+        Q_ASSERT(leQueue);
+        const qint64 timeChunkMS = std::min(timeoutMS - elapsed, timeoutStepMS);
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
+                                     int64_t(timeChunkMS / 1000. * NSEC_PER_SEC)),
+                                     leQueue,
+                                     ^{
+                                           [self handleTimeout];
+                                      });
+    }
+}
+
+- (void)cancelTimer
+{
+    cancelled = true;
+    timeoutHandler = nil;
+}
+
+@end
diff --git a/src/bluetooth/osx/osxbtgcdtimer_p.h b/src/bluetooth/osx/osxbtgcdtimer_p.h
new file mode 100644
index 00000000..007a004b
--- /dev/null
+++ b/src/bluetooth/osx/osxbtgcdtimer_p.h
@@ -0,0 +1,94 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 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 OSXBTGCDTIMER_P_H
+#define OSXBTGCDTIMER_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 "osxbtutility_p.h"
+
+#include <QtCore/qelapsedtimer.h>
+#include <QtCore/qglobal.h>
+
+#include <Foundation/Foundation.h>
+
+@protocol QT_MANGLE_NAMESPACE(GCDTimerDelegate)
+@required
+- (void)timeout;
+@end
+
+@interface QT_MANGLE_NAMESPACE(OSXBTGCDTimer) : NSObject {
+@private
+    qint64 timeoutMS;
+    qint64 timeoutStepMS;
+    QT_PREPEND_NAMESPACE(QElapsedTimer) timer;
+    id<QT_MANGLE_NAMESPACE(GCDTimerDelegate)> timeoutHandler;
+    bool cancelled;
+}
+
+- (instancetype)initWithDelegate:(id<QT_MANGLE_NAMESPACE(GCDTimerDelegate)>)delegate;
+- (void)startWithTimeout:(qint64)ms step:(qint64)stepMS;
+- (void)handleTimeout;
+- (void)cancelTimer;
+
+@end
+
+QT_BEGIN_NAMESPACE
+
+namespace OSXBluetooth {
+
+using GCDTimerObjC = QT_MANGLE_NAMESPACE(OSXBTGCDTimer);
+using GCDTimer = ObjCScopedPointer<GCDTimerObjC>;
+
+}
+
+QT_END_NAMESPACE
+
+#endif // OSXBTGCDTIMER_P_H
+
diff --git a/src/bluetooth/osx/osxbtledeviceinquiry.mm b/src/bluetooth/osx/osxbtledeviceinquiry.mm
index 60222370..2cece15b 100644
--- a/src/bluetooth/osx/osxbtledeviceinquiry.mm
+++ b/src/bluetooth/osx/osxbtledeviceinquiry.mm
@@ -65,9 +65,7 @@ QBluetoothUuid qt_uuid(NSUUID *nsUuid)
 }
 
 const int timeStepMS = 100;
-
 const int powerOffTimeoutMS = 30000;
-const qreal powerOffTimeStepS = 30. / 100.;
 
 struct AdvertisementData {
     // That's what CoreBluetooth has:
@@ -115,14 +113,6 @@ QT_END_NAMESPACE
 
 QT_USE_NAMESPACE
 
-@interface QT_MANGLE_NAMESPACE(OSXBTLEDeviceInquiry) (PrivateAPI) <CBCentralManagerDelegate>
-// These two methods are scheduled with a small time step
-// within a given timeout, they either re-schedule
-// themselves or emit a signal/stop some operation.
-- (void)stopScan;
-- (void)handlePoweredOff;
-@end
-
 @implementation QT_MANGLE_NAMESPACE(OSXBTLEDeviceInquiry)
 
 -(id)initWithNotifier:(LECBManagerNotifier *)aNotifier
@@ -153,60 +143,22 @@ QT_USE_NAMESPACE
     [super dealloc];
 }
 
-- (void)stopScan
+- (void)timeout
 {
-    using namespace OSXBluetooth;
-
-    // We never schedule stopScan if there is no timeout:
-    Q_ASSERT(inquiryTimeoutMS > 0);
-
     if (internalState == InquiryActive) {
-        const int elapsed = scanTimer.elapsed();
-        if (elapsed >= inquiryTimeoutMS) {
-            [manager stopScan];
-            [manager setDelegate:nil];
-            internalState = InquiryFinished;
-            Q_ASSERT(notifier);
-            emit notifier->discoveryFinished();
-        } else {
-            // Re-schedule 'stopScan':
-            dispatch_queue_t leQueue(qt_LE_queue());
-            Q_ASSERT(leQueue);
-            const int timeChunkMS = std::min(inquiryTimeoutMS - elapsed, timeStepMS);
-            dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
-                                         int64_t(timeChunkMS / 1000. * NSEC_PER_SEC)),
-                                         leQueue,
-                                         ^{
-                                               [self stopScan];
-                                          });
-        }
-    }
-}
-
-- (void)handlePoweredOff
-{
-    // This is interesting on iOS only, where
-    // the system shows an alert asking to enable
-    // Bluetooth in the 'Settings' app. If not done yet (after 30
-    // seconds) - we consider it an error.
-    using namespace OSXBluetooth;
-
-    if (internalState == InquiryStarting) {
-        if (errorTimer.elapsed() >= powerOffTimeoutMS) {
-            [manager setDelegate:nil];
-            internalState = ErrorPoweredOff;
-            Q_ASSERT(notifier);
-            emit notifier->CBManagerError(QBluetoothDeviceDiscoveryAgent::PoweredOffError);
-        } else {
-            dispatch_queue_t leQueue(qt_LE_queue());
-            Q_ASSERT(leQueue);
-            dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
-                                         (int64_t)(powerOffTimeStepS * NSEC_PER_SEC)),
-                                         leQueue,
-                                         ^{
-                                              [self handlePoweredOff];
-                                          });
-        }
+        [manager stopScan];
+        [manager setDelegate:nil];
+        internalState = InquiryFinished;
+        Q_ASSERT(notifier);
+        emit notifier->discoveryFinished();
+    } else if (internalState == InquiryStarting) {
+        // This is interesting on iOS only, where the system shows an alert
+        // asking to enable Bluetooth in the 'Settings' app. If not done yet
+        // (after 30 seconds) - we consider this as an error.
+        [manager setDelegate:nil];
+        internalState = ErrorPoweredOff;
+        Q_ASSERT(notifier);
+        emit notifier->CBManagerError(QBluetoothDeviceDiscoveryAgent::PoweredOffError);
     }
 }
 
@@ -233,9 +185,6 @@ QT_USE_NAMESPACE
 
     using namespace OSXBluetooth;
 
-    dispatch_queue_t leQueue(qt_LE_queue());
-    Q_ASSERT(leQueue);
-
     const auto state = central.state;
 #if QT_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(__IPHONE_10_0) || QT_OSX_PLATFORM_SDK_EQUAL_OR_ABOVE(__MAC_10_13)
     if (state == CBManagerStatePoweredOn) {
@@ -246,18 +195,9 @@ QT_USE_NAMESPACE
             internalState = InquiryActive;
 
             if (inquiryTimeoutMS > 0) {
-                // We have a finite-length discovery, schedule stopScan,
-                // with a smaller time step, otherwise it can prevent
-                // 'self' from being deleted in time, which is not good
-                // (the block will retain 'self', waiting for timeout).
-                scanTimer.start();
-                const int timeChunkMS = std::min(timeStepMS, inquiryTimeoutMS);
-                dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
-                                             int64_t(timeChunkMS / 1000. * NSEC_PER_SEC)),
-                                             leQueue,
-                                             ^{
-                                                   [self stopScan];
-                                              });
+                [elapsedTimer cancelTimer];
+                elapsedTimer.reset([[GCDTimerObjC alloc] initWithDelegate:self]);
+                [elapsedTimer startWithTimeout:inquiryTimeoutMS step:timeStepMS];
             }
 
             [manager scanForPeripheralsWithServices:nil options:nil];
@@ -287,19 +227,15 @@ QT_USE_NAMESPACE
         if (internalState == InquiryStarting) {
 #ifndef Q_OS_OSX
             // On iOS a user can see at this point an alert asking to
-            // enable Bluetooth in the "Settings" app. If a user does,
+            // enable Bluetooth in the "Settings" app. If a user does so,
             // we'll receive 'PoweredOn' state update later.
-            // No change in internalState. Wait for 30 seconds
-            // (we split it into smaller steps not to retain 'self' for
-            // too long ) ...
-            errorTimer.start();
-            dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
-                                         (int64_t)(powerOffTimeStepS * NSEC_PER_SEC)),
-                                         leQueue,
-                                         ^{
-                                              [self handlePoweredOff];
-                                          });
+            // No change in internalState. Wait for 30 seconds.
+            [elapsedTimer cancelTimer];
+            elapsedTimer.reset([[GCDTimerObjC alloc] initWithDelegate:self]);
+            [elapsedTimer startWithTimeout:powerOffTimeoutMS step:300];
             return;
+#else
+            Q_UNUSED(powerOffTimeoutMS)
 #endif
             internalState = ErrorPoweredOff;
             emit notifier->CBManagerError(QBluetoothDeviceDiscoveryAgent::PoweredOffError);
@@ -330,6 +266,8 @@ QT_USE_NAMESPACE
     if (internalState == InquiryActive)
         [manager stopScan];
 
+    [elapsedTimer cancelTimer];
+
     [manager setDelegate:nil];
     internalState = InquiryCancelled;
 
diff --git a/src/bluetooth/osx/osxbtledeviceinquiry_p.h b/src/bluetooth/osx/osxbtledeviceinquiry_p.h
index fc787a6d..a19055ab 100644
--- a/src/bluetooth/osx/osxbtledeviceinquiry_p.h
+++ b/src/bluetooth/osx/osxbtledeviceinquiry_p.h
@@ -53,10 +53,10 @@
 
 #include "qbluetoothdevicediscoveryagent.h"
 #include "qbluetoothdeviceinfo.h"
+#include "osxbtgcdtimer_p.h"
 #include "osxbtutility_p.h"
 #include "osxbluetooth_p.h"
 
-#include <QtCore/qelapsedtimer.h>
 #include <QtCore/qglobal.h>
 #include <QtCore/qlist.h>
 
@@ -75,10 +75,8 @@ class LECBManagerNotifier;
 
 QT_END_NAMESPACE
 
-// Ugly but all these QT_PREPEND_NAMESPACE etc. are even worse ...
-using OSXBluetooth::LECBManagerNotifier;
-using OSXBluetooth::ObjCScopedPointer;
-using QT_PREPEND_NAMESPACE(QElapsedTimer);
+using QT_PREPEND_NAMESPACE(OSXBluetooth)::LECBManagerNotifier;
+using QT_PREPEND_NAMESPACE(OSXBluetooth)::ObjCScopedPointer;
 
 enum LEInquiryState
 {
@@ -90,7 +88,7 @@ enum LEInquiryState
     ErrorLENotSupported
 };
 
-@interface QT_MANGLE_NAMESPACE(OSXBTLEDeviceInquiry) : NSObject
+@interface QT_MANGLE_NAMESPACE(OSXBTLEDeviceInquiry) : NSObject<CBCentralManagerDelegate, QT_MANGLE_NAMESPACE(GCDTimerDelegate)>
 {
     LECBManagerNotifier *notifier;
     ObjCScopedPointer<CBCentralManager> manager;
@@ -99,16 +97,14 @@ enum LEInquiryState
     LEInquiryState internalState;
     int inquiryTimeoutMS;
 
-    // Timers to check if we can execute delayed callbacks:
-    QT_PREPEND_NAMESPACE(QElapsedTimer) errorTimer;
-    QT_PREPEND_NAMESPACE(QElapsedTimer) scanTimer;
+    QT_PREPEND_NAMESPACE(OSXBluetooth)::GCDTimer elapsedTimer;
 }
 
 - (id)initWithNotifier:(LECBManagerNotifier *)aNotifier;
 - (void)dealloc;
 
-// IMPORTANT: both 'startWithTimeout' and 'stop'
-// can be executed only on the "Qt's LE queue".
+// IMPORTANT: both 'startWithTimeout' and 'stop' MUST be executed on the "Qt's
+// LE queue".
 - (void)startWithTimeout:(int)timeout;
 - (void)stop;
 
diff --git a/src/bluetooth/qbluetoothdevicediscoveryagent_android.cpp b/src/bluetooth/qbluetoothdevicediscoveryagent_android.cpp
index 303dd67f..c7afd578 100644
--- a/src/bluetooth/qbluetoothdevicediscoveryagent_android.cpp
+++ b/src/bluetooth/qbluetoothdevicediscoveryagent_android.cpp
@@ -147,23 +147,33 @@ void QBluetoothDeviceDiscoveryAgentPrivate::start(QBluetoothDeviceDiscoveryAgent
     }
 
     // check Android v23+ permissions
-    // -> BTLE search requires android.permission.ACCESS_COARSE_LOCATION
+    // -> BTLE search requires android.permission.ACCESS_COARSE_LOCATION or android.permission.ACCESS_FINE_LOCATION
     if (requestedMethods & QBluetoothDeviceDiscoveryAgent::LowEnergyMethod
         && QtAndroid::androidSdkVersion() >= 23)
     {
-        QString permission(QLatin1String("android.permission.ACCESS_COARSE_LOCATION"));
+        const QString coarsePermission(QLatin1String("android.permission.ACCESS_COARSE_LOCATION"));
+        const QString finePermission(QLatin1String("android.permission.ACCESS_FINE_LOCATION"));
 
         // do we have required permission already, if so nothing to do
-        if (QtAndroidPrivate::checkPermission(permission) == QtAndroidPrivate::PermissionsResult::Denied) {
-            qCWarning(QT_BT_ANDROID) << "Requesting ACCESS_COARSE_LOCATION permission";
+        if (QtAndroidPrivate::checkPermission(coarsePermission) == QtAndroidPrivate::PermissionsResult::Denied
+            && QtAndroidPrivate::checkPermission(finePermission) == QtAndroidPrivate::PermissionsResult::Denied) {
+            qCWarning(QT_BT_ANDROID) << "Requesting ACCESS_*_LOCATION permission";
 
             QAndroidJniEnvironment env;
             const QHash<QString, QtAndroidPrivate::PermissionsResult> results =
-                    QtAndroidPrivate::requestPermissionsSync(env, QStringList() << permission);
-            if (!results.contains(permission)
-                || results[permission] == QtAndroidPrivate::PermissionsResult::Denied)
-            {
-                qCWarning(QT_BT_ANDROID) << "Search not possible due to missing permission (ACCESS_COARSE_LOCATION)";
+                    QtAndroidPrivate::requestPermissionsSync(env, QStringList() << coarsePermission << finePermission);
+
+            bool permissionReceived = false;
+            for (const QString &permission: results.keys()) {
+                qCDebug(QT_BT_ANDROID) << permission << (results[permission] == QtAndroidPrivate::PermissionsResult::Denied);
+                if ((permission == coarsePermission || permission == finePermission)
+                    && results[permission] == QtAndroidPrivate::PermissionsResult::Granted) {
+                        permissionReceived = true;
+                        break;
+                }
+            }
+            if (!permissionReceived) {
+                qCWarning(QT_BT_ANDROID) << "Search not possible due to missing permission (ACCESS_COARSE|FINE_LOCATION)";
                 lastError = QBluetoothDeviceDiscoveryAgent::UnknownError;
                 errorString = QBluetoothDeviceDiscoveryAgent::tr("Missing Location permission. Search is not possible.");
                 emit q->error(lastError);
@@ -171,7 +181,7 @@ void QBluetoothDeviceDiscoveryAgentPrivate::start(QBluetoothDeviceDiscoveryAgent
             }
         }
 
-        qCWarning(QT_BT_ANDROID) << "ACCESS_COARSE_LOCATION permission available";
+        qCWarning(QT_BT_ANDROID) << "ACCESS_COARSE|FINE_LOCATION permission available";
     }
 
     // install Java BroadcastReceiver
diff --git a/src/bluetooth/qbluetoothdevicediscoveryagent_winrt.cpp b/src/bluetooth/qbluetoothdevicediscoveryagent_winrt.cpp
index 6786ac54..309804a8 100644
--- a/src/bluetooth/qbluetoothdevicediscoveryagent_winrt.cpp
+++ b/src/bluetooth/qbluetoothdevicediscoveryagent_winrt.cpp
@@ -92,7 +92,7 @@ private:
                                    QBluetoothDeviceDiscoveryAgent::DiscoveryMethod mode);
     void gatherDeviceInformation(IDeviceInformation *deviceInfo,
                                  QBluetoothDeviceDiscoveryAgent::DiscoveryMethod mode);
-    void gatherMultipleDeviceInformation(IVectorView<DeviceInformation *> *devices,
+    void gatherMultipleDeviceInformation(quint32 deviceCount, IVectorView<DeviceInformation *> *devices,
                                          QBluetoothDeviceDiscoveryAgent::DiscoveryMethod mode);
     void setupLEDeviceWatcher();
     void classicBluetoothInfoFromDeviceIdAsync(HSTRING deviceId);
@@ -207,7 +207,20 @@ void QWinRTBluetoothDeviceDiscoveryWorker::onDeviceDiscoveryFinished(IAsyncOpera
     HRESULT hr;
     hr = op->GetResults(&devices);
     Q_ASSERT_SUCCEEDED(hr);
-    gatherMultipleDeviceInformation(devices.Get(), mode);
+    quint32 deviceCount;
+    hr = devices->get_Size(&deviceCount);
+    Q_ASSERT_SUCCEEDED(hr);
+
+    // For classic discovery only paired devices will be found. If we only do classic disovery and
+    // no device is found, the scan is finished.
+    if (requestedModes == QBluetoothDeviceDiscoveryAgent::ClassicMethod &&
+        deviceCount == 0) {
+        finishDiscovery();
+        return;
+    }
+
+    m_pendingPairedDevices += deviceCount;
+    gatherMultipleDeviceInformation(deviceCount, devices.Get(), mode);
 }
 
 void QWinRTBluetoothDeviceDiscoveryWorker::gatherDeviceInformation(IDeviceInformation *deviceInfo, QBluetoothDeviceDiscoveryAgent::DiscoveryMethod mode)
@@ -222,15 +235,11 @@ void QWinRTBluetoothDeviceDiscoveryWorker::gatherDeviceInformation(IDeviceInform
         classicBluetoothInfoFromDeviceIdAsync(deviceId.Get());
 }
 
-void QWinRTBluetoothDeviceDiscoveryWorker::gatherMultipleDeviceInformation(IVectorView<DeviceInformation *> *devices, QBluetoothDeviceDiscoveryAgent::DiscoveryMethod mode)
+void QWinRTBluetoothDeviceDiscoveryWorker::gatherMultipleDeviceInformation(quint32 deviceCount, IVectorView<DeviceInformation *> *devices, QBluetoothDeviceDiscoveryAgent::DiscoveryMethod mode)
 {
-    quint32 deviceCount;
-    HRESULT hr = devices->get_Size(&deviceCount);
-    Q_ASSERT_SUCCEEDED(hr);
-    m_pendingPairedDevices += deviceCount;
     for (quint32 i = 0; i < deviceCount; ++i) {
         ComPtr<IDeviceInformation> device;
-        hr = devices->GetAt(i, &device);
+        HRESULT hr = devices->GetAt(i, &device);
         Q_ASSERT_SUCCEEDED(hr);
         gatherDeviceInformation(device.Get(), mode);
     }
@@ -374,34 +383,39 @@ HRESULT QWinRTBluetoothDeviceDiscoveryWorker::onPairedClassicBluetoothDeviceFoun
     Q_ASSERT_SUCCEEDED(hr);
     IVectorView <Rfcomm::RfcommDeviceService *> *deviceServices;
     hr = device->get_RfcommServices(&deviceServices);
-    Q_ASSERT_SUCCEEDED(hr);
-    uint serviceCount;
-    hr = deviceServices->get_Size(&serviceCount);
-    Q_ASSERT_SUCCEEDED(hr);
-    QList<QBluetoothUuid> uuids;
-    for (uint i = 0; i < serviceCount; ++i) {
-        ComPtr<Rfcomm::IRfcommDeviceService> service;
-        hr = deviceServices->GetAt(i, &service);
-        Q_ASSERT_SUCCEEDED(hr);
-        ComPtr<Rfcomm::IRfcommServiceId> id;
-        hr = service->get_ServiceId(&id);
+    if (hr == E_ACCESSDENIED) {
+        qCWarning(QT_BT_WINRT) << "Could not obtain device services. Please check you have "
+                                  "permission to access the device.";
+    } else {
         Q_ASSERT_SUCCEEDED(hr);
-        GUID uuid;
-        hr = id->get_Uuid(&uuid);
+        uint serviceCount;
+        hr = deviceServices->get_Size(&serviceCount);
         Q_ASSERT_SUCCEEDED(hr);
-        uuids.append(QBluetoothUuid(uuid));
-    }
+        QList<QBluetoothUuid> uuids;
+        for (uint i = 0; i < serviceCount; ++i) {
+            ComPtr<Rfcomm::IRfcommDeviceService> service;
+            hr = deviceServices->GetAt(i, &service);
+            Q_ASSERT_SUCCEEDED(hr);
+            ComPtr<Rfcomm::IRfcommServiceId> id;
+            hr = service->get_ServiceId(&id);
+            Q_ASSERT_SUCCEEDED(hr);
+            GUID uuid;
+            hr = id->get_Uuid(&uuid);
+            Q_ASSERT_SUCCEEDED(hr);
+            uuids.append(QBluetoothUuid(uuid));
+        }
 
-    qCDebug(QT_BT_WINRT) << "Discovered BT device: " << QString::number(address) << btName
-        << "Num UUIDs" << uuids.count();
+        qCDebug(QT_BT_WINRT) << "Discovered BT device: " << QString::number(address) << btName
+            << "Num UUIDs" << uuids.count();
 
-    QBluetoothDeviceInfo info(QBluetoothAddress(address), btName, classOfDeviceInt);
-    info.setCoreConfigurations(QBluetoothDeviceInfo::BaseRateCoreConfiguration);
-    info.setServiceUuids(uuids, QBluetoothDeviceInfo::DataIncomplete);
-    info.setCached(true);
+        QBluetoothDeviceInfo info(QBluetoothAddress(address), btName, classOfDeviceInt);
+        info.setCoreConfigurations(QBluetoothDeviceInfo::BaseRateCoreConfiguration);
+        info.setServiceUuids(uuids, QBluetoothDeviceInfo::DataIncomplete);
+        info.setCached(true);
 
-    QMetaObject::invokeMethod(this, "deviceFound", Qt::AutoConnection,
-                              Q_ARG(QBluetoothDeviceInfo, info));
+        QMetaObject::invokeMethod(this, "deviceFound", Qt::AutoConnection,
+                                  Q_ARG(QBluetoothDeviceInfo, info));
+    }
     if (!m_pendingPairedDevices && !(requestedModes & QBluetoothDeviceDiscoveryAgent::LowEnergyMethod))
         finishDiscovery();
     return S_OK;
diff --git a/src/bluetooth/qbluetoothlocaldevice.cpp b/src/bluetooth/qbluetoothlocaldevice.cpp
index 40d86ae3..78095beb 100644
--- a/src/bluetooth/qbluetoothlocaldevice.cpp
+++ b/src/bluetooth/qbluetoothlocaldevice.cpp
@@ -56,7 +56,7 @@ QT_BEGIN_NAMESPACE
     QBluetoothLocalDevice provides functions for getting and setting the state of local Bluetooth
     devices.
 
-    On iOS, this class cannot be used because the platform does not expose
+    On iOS and Windows, this class cannot be used because the platform does not expose
     any data or API which may provide information on the local Bluetooth device.
 */
 
@@ -270,9 +270,9 @@ bool QBluetoothLocalDevice::isValid() const
 */
 
 /*!
-  \fn QBluetoothLocalDevice::pairingConfirmation(bool accept)
+  \fn QBluetoothLocalDevice::pairingConfirmation(bool confirmation)
 
-  To be called after getting a pairingDisplayConfirmation().  The \a accept parameter either
+  To be called after getting a pairingDisplayConfirmation().  The \a confirmation parameter either
   accepts the pairing or rejects it.
 
   Accepting a pairing always refers to the last pairing request issued via \l requestPairing().
diff --git a/src/bluetooth/qbluetoothlocaldevice_bluez.cpp b/src/bluetooth/qbluetoothlocaldevice_bluez.cpp
index 4eb3ca58..c247f679 100644
--- a/src/bluetooth/qbluetoothlocaldevice_bluez.cpp
+++ b/src/bluetooth/qbluetoothlocaldevice_bluez.cpp
@@ -529,16 +529,20 @@ void QBluetoothLocalDevicePrivate::processPairingBluez5(const QString &objectPat
     switch (target) {
     case QBluetoothLocalDevice::Unpaired: {
         delete pairingTarget;
-        pairingTarget = 0;
+        pairingTarget = nullptr;
 
         QDBusPendingReply<> removeReply = adapterBluez5->RemoveDevice(QDBusObjectPath(objectPath));
-        removeReply.waitForFinished();
-
-        if (removeReply.isError())
-            emit q->error(QBluetoothLocalDevice::PairingError);
-        else
-            emit q->pairingFinished(targetAddress, QBluetoothLocalDevice::Unpaired);
+        auto watcher = new QDBusPendingCallWatcher(removeReply, this);
+        connect(watcher, &QDBusPendingCallWatcher::finished,
+                this, [q, targetAddress](QDBusPendingCallWatcher* watcher){
+            QDBusPendingReply<> reply = *watcher;
+            if (reply.isError())
+                emit q->error(QBluetoothLocalDevice::PairingError);
+            else
+                emit q->pairingFinished(targetAddress, QBluetoothLocalDevice::Unpaired);
 
+            watcher->deleteLater();
+        });
         break;
     }
     case QBluetoothLocalDevice::Paired:
diff --git a/src/bluetooth/qbluetoothserver.cpp b/src/bluetooth/qbluetoothserver.cpp
index 90c3ff19..d9e42adf 100644
--- a/src/bluetooth/qbluetoothserver.cpp
+++ b/src/bluetooth/qbluetoothserver.cpp
@@ -189,7 +189,7 @@ QBluetoothServer::~QBluetoothServer()
     required to call \l QBluetoothServiceInfo::unregisterService() and \l close() on this
     server object.
 
-    Returns a registered QBluetoothServiceInfo instance if sucessful otherwise an
+    Returns a registered QBluetoothServiceInfo instance if successful otherwise an
     invalid QBluetoothServiceInfo. This function always assumes that the default Bluetooth adapter
     should be used.
 
diff --git a/src/bluetooth/qbluetoothserver_android.cpp b/src/bluetooth/qbluetoothserver_android.cpp
index 7d3d3588..b001adb8 100644
--- a/src/bluetooth/qbluetoothserver_android.cpp
+++ b/src/bluetooth/qbluetoothserver_android.cpp
@@ -41,7 +41,7 @@
 #include "qbluetoothserver.h"
 #include "qbluetoothserver_p.h"
 #include "qbluetoothsocket.h"
-#include "qbluetoothsocket_p.h"
+#include "qbluetoothsocket_android_p.h"
 #include "qbluetoothlocaldevice.h"
 #include "android/serveracceptancethread_p.h"
 
diff --git a/src/bluetooth/qbluetoothserver_osx.mm b/src/bluetooth/qbluetoothserver_osx.mm
index a1774d14..d7f29ed3 100644
--- a/src/bluetooth/qbluetoothserver_osx.mm
+++ b/src/bluetooth/qbluetoothserver_osx.mm
@@ -43,7 +43,7 @@
 // The order is important: a workround for
 // a private header included by private header
 // (incorrectly handled dependencies).
-#include "qbluetoothsocket_p.h"
+#include "qbluetoothsocketbase_p.h"
 #include "qbluetoothsocket_osx_p.h"
 
 #include "qbluetoothlocaldevice.h"
diff --git a/src/bluetooth/qbluetoothserver_winrt.cpp b/src/bluetooth/qbluetoothserver_winrt.cpp
index 08aa45b4..a53ef110 100644
--- a/src/bluetooth/qbluetoothserver_winrt.cpp
+++ b/src/bluetooth/qbluetoothserver_winrt.cpp
@@ -40,7 +40,7 @@
 #include "qbluetoothserver.h"
 #include "qbluetoothserver_p.h"
 #include "qbluetoothsocket.h"
-#include "qbluetoothsocket_p.h"
+#include "qbluetoothsocket_winrt_p.h"
 
 #include <QtCore/QLoggingCategory>
 #include <QtCore/private/qeventdispatcher_winrt_p.h>
diff --git a/src/bluetooth/qbluetoothsocket.cpp b/src/bluetooth/qbluetoothsocket.cpp
index ddc6469f..dae844d7 100644
--- a/src/bluetooth/qbluetoothsocket.cpp
+++ b/src/bluetooth/qbluetoothsocket.cpp
@@ -39,13 +39,18 @@
 ****************************************************************************/
 
 #include "qbluetoothsocket.h"
-#include "qbluetoothsocket_p.h"
+#if QT_CONFIG(bluez)
+#include "qbluetoothsocket_bluez_p.h"
+#elif defined(QT_ANDROID_BLUETOOTH)
+#include "qbluetoothsocket_android_p.h"
+#elif defined(QT_WINRT_BLUETOOTH)
+#include "qbluetoothsocket_winrt_p.h"
+#else
+#include "qbluetoothsocket_dummy_p.h"
+#endif
 
-#include "qbluetoothdeviceinfo.h"
-#include "qbluetoothserviceinfo.h"
 #include "qbluetoothservicediscoveryagent.h"
 
-
 #include <QtCore/QLoggingCategory>
 #include <QSocketNotifier>
 
@@ -250,11 +255,20 @@ Q_DECLARE_LOGGING_CATEGORY(QT_BT)
     Constructs a Bluetooth socket of \a socketType type, with \a parent.
 */
 QBluetoothSocket::QBluetoothSocket(QBluetoothServiceInfo::Protocol socketType, QObject *parent)
-: QIODevice(parent), d_ptr(new QBluetoothSocketPrivate)
-{
+: QIODevice(parent)
+{
+#if QT_CONFIG(bluez)
+    d_ptr = new QBluetoothSocketPrivateBluez();
+#elif defined(QT_ANDROID_BLUETOOTH)
+    d_ptr = new QBluetoothSocketPrivateAndroid();
+#elif defined(QT_WINRT_BLUETOOTH)
+    d_ptr = new QBluetoothSocketPrivateWinRT();
+#else
+    d_ptr = new QBluetoothSocketPrivateDummy();
+#endif
     d_ptr->q_ptr = this;
 
-    Q_D(QBluetoothSocket);
+    Q_D(QBluetoothSocketBase);
     d->ensureNativeSocket(socketType);
 
     setOpenMode(QIODevice::NotOpen);
@@ -264,8 +278,17 @@ QBluetoothSocket::QBluetoothSocket(QBluetoothServiceInfo::Protocol socketType, Q
     Constructs a Bluetooth socket with \a parent.
 */
 QBluetoothSocket::QBluetoothSocket(QObject *parent)
-  : QIODevice(parent), d_ptr(new QBluetoothSocketPrivate)
-{
+  : QIODevice(parent)
+{
+#if QT_CONFIG(bluez)
+    d_ptr = new QBluetoothSocketPrivateBluez();
+#elif defined(QT_ANDROID_BLUETOOTH)
+    d_ptr = new QBluetoothSocketPrivateAndroid();
+#elif defined(QT_WINRT_BLUETOOTH)
+    d_ptr = new QBluetoothSocketPrivateWinRT();
+#else
+    d_ptr = new QBluetoothSocketPrivateDummy();
+#endif
     d_ptr->q_ptr = this;
     setOpenMode(QIODevice::NotOpen);
 }
@@ -294,7 +317,7 @@ bool QBluetoothSocket::isSequential() const
 */
 qint64 QBluetoothSocket::bytesAvailable() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return QIODevice::bytesAvailable() + d->bytesAvailable();
 }
 
@@ -304,7 +327,7 @@ qint64 QBluetoothSocket::bytesAvailable() const
 */
 qint64 QBluetoothSocket::bytesToWrite() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->bytesToWrite();
 }
 
@@ -327,67 +350,12 @@ qint64 QBluetoothSocket::bytesToWrite() const
 */
 void QBluetoothSocket::connectToService(const QBluetoothServiceInfo &service, OpenMode openMode)
 {
-    Q_D(QBluetoothSocket);
-
-    if (state() != QBluetoothSocket::UnconnectedState && state() != QBluetoothSocket::ServiceLookupState) {
-        qCWarning(QT_BT)  << "QBluetoothSocket::connectToService called on busy socket";
-        d->errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
-        setSocketError(QBluetoothSocket::OperationError);
-        return;
-    }
-#if defined(QT_ANDROID_BLUETOOTH)
-    if (!d->ensureNativeSocket(service.socketProtocol())) {
-        d->errorString = tr("Socket type not supported");
-        setSocketError(QBluetoothSocket::UnsupportedProtocolError);
-        return;
-    }
-    d->connectToService(service.device().address(), service.serviceUuid(), openMode);
-#else
-#if defined(QT_WINRT_BLUETOOTH)
-    // Report these problems early:
-    if (socketType() != QBluetoothServiceInfo::RfcommProtocol) {
-        d->errorString = tr("Socket type not supported");
-        setSocketError(QBluetoothSocket::UnsupportedProtocolError);
-        return;
-    }
-#endif // QT_WINRT_BLUETOOTH
-    if (socketType() == QBluetoothServiceInfo::UnknownProtocol) {
-        qCWarning(QT_BT) << "QBluetoothSocket::connectToService cannot "
-                            "connect with 'UnknownProtocol' type";
-        d->errorString = tr("Socket type not supported");
-        setSocketError(QBluetoothSocket::UnsupportedProtocolError);
-        return;
-    }
-
-    if (service.protocolServiceMultiplexer() > 0) {
-        if (!d->ensureNativeSocket(QBluetoothServiceInfo::L2capProtocol)) {
-            d->errorString = tr("Unknown socket error");
-            setSocketError(UnknownSocketError);
-            return;
-        }
-        d->connectToService(service.device().address(), service.protocolServiceMultiplexer(), openMode);
-    } else if (service.serverChannel() > 0) {
-        if (!d->ensureNativeSocket(QBluetoothServiceInfo::RfcommProtocol)) {
-            d->errorString = tr("Unknown socket error");
-            setSocketError(UnknownSocketError);
-            return;
-        }
-        d->connectToService(service.device().address(), service.serverChannel(), openMode);
-    } else {
-        // try doing service discovery to see if we can find the socket
-        if (service.serviceUuid().isNull()
-                && !service.serviceClassUuids().contains(QBluetoothUuid::SerialPort)) {
-            qCWarning(QT_BT) << "No port, no PSM, and no UUID provided, unable to connect";
-            return;
-        }
-        qCDebug(QT_BT) << "Need a port/psm, doing discovery";
-        doDeviceDiscovery(service, openMode);
-    }
-#endif
+    Q_D(QBluetoothSocketBase);
+    d->connectToService(service, openMode);
 }
 
 /*!
-  \fn void QBluetoothSocket::connectToService(const QBluetoothAddress &address, QBluetoothUuid::ServiceClassUuid uuid, OpenMode openMode = ReadWrite)
+  \fn void QBluetoothSocket::connectToService(const QBluetoothAddress &address, QBluetoothUuid::ServiceClassUuid uuid, OpenMode mode = ReadWrite)
 
   \internal
 
@@ -403,10 +371,10 @@ void QBluetoothSocket::connectToService(const QBluetoothServiceInfo &service, Op
     For BlueZ, the socket first enters the \l ServiceLookupState and queries the connection parameters for
     \a uuid. If the service parameters are successfully retrieved the socket enters
     ConnectingState, and attempts to connect to \a address. If a connection is established,
-    QBluetoothSocket enters Connected State and emits connected().
+    QBluetoothSocket enters \l ConnectedState and emits connected().
 
     On Android, the service connection can directly be established
-    using the UUID of the remote service. Therefore the platforms does not require
+    using the UUID of the remote service. Therefore the platform does not require
     the \l ServiceLookupState and \l socketType() is always set to
     \l QBluetoothServiceInfo::RfcommProtocol.
 
@@ -419,45 +387,8 @@ void QBluetoothSocket::connectToService(const QBluetoothServiceInfo &service, Op
 */
 void QBluetoothSocket::connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid, OpenMode openMode)
 {
-    Q_D(QBluetoothSocket);
-
-    if (state() != QBluetoothSocket::UnconnectedState) {
-        qCWarning(QT_BT)  << "QBluetoothSocket::connectToService called on busy socket";
-        d->errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
-        setSocketError(QBluetoothSocket::OperationError);
-        return;
-    }
-
-#if defined(QT_ANDROID_BLUETOOTH)
-    if (!d->ensureNativeSocket(QBluetoothServiceInfo::RfcommProtocol)) {
-        d->errorString = tr("Socket type not supported");
-        setSocketError(QBluetoothSocket::UnsupportedProtocolError);
-        return;
-    }
+    Q_D(QBluetoothSocketBase);
     d->connectToService(address, uuid, openMode);
-#else
-#if defined(QT_WINRT_BLUETOOTH)
-    // Report these problems early, prevent device discovery:
-    if (socketType() != QBluetoothServiceInfo::RfcommProtocol) {
-        d->errorString = tr("Socket type not supported");
-        setSocketError(QBluetoothSocket::UnsupportedProtocolError);
-        return;
-    }
-#endif // QT_WINRT_BLUETOOTH
-    if (socketType() == QBluetoothServiceInfo::UnknownProtocol) {
-        qCWarning(QT_BT) << "QBluetoothSocket::connectToService cannot "
-                            "connect with 'UnknownProtocol' type";
-        d->errorString = tr("Socket type not supported");
-        setSocketError(QBluetoothSocket::UnsupportedProtocolError);
-        return;
-    }
-
-    QBluetoothServiceInfo service;
-    QBluetoothDeviceInfo device(address, QString(), QBluetoothDeviceInfo::MiscellaneousDevice);
-    service.setDevice(device);
-    service.setServiceUuid(uuid);
-    doDeviceDiscovery(service, openMode);
-#endif
 }
 
 /*!
@@ -471,7 +402,7 @@ void QBluetoothSocket::connectToService(const QBluetoothAddress &address, const
     At any point, the socket can emit error() to signal that an error occurred.
 
     On Android, a connection to a service can not be established using a port. Calling this function
-    will emit a \l {QBluetoothSocket::ServiceNotFoundError}{ServiceNotFoundError}
+    will emit a \l {QBluetoothSocket::ServiceNotFoundError}{ServiceNotFoundError}.
 
     Note that most platforms require a pairing prior to connecting to the remote device. Otherwise
     the connection process may fail.
@@ -480,41 +411,8 @@ void QBluetoothSocket::connectToService(const QBluetoothAddress &address, const
 */
 void QBluetoothSocket::connectToService(const QBluetoothAddress &address, quint16 port, OpenMode openMode)
 {
-    Q_D(QBluetoothSocket);
-#if defined(QT_ANDROID_BLUETOOTH)
-    Q_UNUSED(port);
-    Q_UNUSED(openMode);
-    Q_UNUSED(address);
-    d->errorString = tr("Connecting to port is not supported");
-    setSocketError(QBluetoothSocket::ServiceNotFoundError);
-    qCWarning(QT_BT) << "Connecting to port is not supported";
-#else
-#if defined(QT_WINRT_BLUETOOTH)
-    // Report these problems early
-    if (socketType() != QBluetoothServiceInfo::RfcommProtocol) {
-        d->errorString = tr("Socket type not supported");
-        setSocketError(QBluetoothSocket::UnsupportedProtocolError);
-        return;
-    }
-#endif // QT_WINRT_BLUETOOTH
-    if (socketType() == QBluetoothServiceInfo::UnknownProtocol) {
-        qCWarning(QT_BT) << "QBluetoothSocket::connectToService cannot "
-                            "connect with 'UnknownProtocol' type";
-        d->errorString = tr("Socket type not supported");
-        setSocketError(QBluetoothSocket::UnsupportedProtocolError);
-        return;
-    }
-
-    if (state() != QBluetoothSocket::UnconnectedState) {
-        qCWarning(QT_BT)  << "QBluetoothSocket::connectToService called on busy socket";
-        d->errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
-        setSocketError(QBluetoothSocket::OperationError);
-        return;
-    }
-
-    setOpenMode(openMode);
+    Q_D(QBluetoothSocketBase);
     d->connectToService(address, port, openMode);
-#endif
 }
 
 /*!
@@ -526,7 +424,7 @@ void QBluetoothSocket::connectToService(const QBluetoothAddress &address, quint1
 */
 QBluetoothServiceInfo::Protocol QBluetoothSocket::socketType() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->socketType;
 }
 
@@ -535,7 +433,7 @@ QBluetoothServiceInfo::Protocol QBluetoothSocket::socketType() const
 */
 QBluetoothSocket::SocketState QBluetoothSocket::state() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->state;
 }
 
@@ -544,7 +442,7 @@ QBluetoothSocket::SocketState QBluetoothSocket::state() const
 */
 QBluetoothSocket::SocketError QBluetoothSocket::error() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->socketError;
 }
 
@@ -553,7 +451,7 @@ QBluetoothSocket::SocketError QBluetoothSocket::error() const
  */
 QString QBluetoothSocket::errorString() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->errorString;
 }
 
@@ -586,7 +484,7 @@ QString QBluetoothSocket::errorString() const
 */
 void QBluetoothSocket::setPreferredSecurityFlags(QBluetooth::SecurityFlags flags)
 {
-    Q_D(QBluetoothSocket);
+    Q_D(QBluetoothSocketBase);
     if (d->secFlags != flags)
         d->secFlags = flags;
 }
@@ -607,7 +505,7 @@ void QBluetoothSocket::setPreferredSecurityFlags(QBluetooth::SecurityFlags flags
 */
 QBluetooth::SecurityFlags QBluetoothSocket::preferredSecurityFlags() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->secFlags;
 }
 
@@ -616,7 +514,7 @@ QBluetooth::SecurityFlags QBluetoothSocket::preferredSecurityFlags() const
 */
 void QBluetoothSocket::setSocketState(QBluetoothSocket::SocketState state)
 {
-    Q_D(QBluetoothSocket);
+    Q_D(QBluetoothSocketBase);
     SocketState old = d->state;
     d->state = state;
     if(old != d->state)
@@ -636,7 +534,7 @@ void QBluetoothSocket::setSocketState(QBluetoothSocket::SocketState state)
 
 bool QBluetoothSocket::canReadLine() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->canReadLine();
 }
 
@@ -645,7 +543,7 @@ bool QBluetoothSocket::canReadLine() const
 */
 void QBluetoothSocket::setSocketError(QBluetoothSocket::SocketError error_)
 {
-    Q_D(QBluetoothSocket);
+    Q_D(QBluetoothSocketBase);
     d->socketError = error_;
     emit error(error_);
 }
@@ -658,10 +556,10 @@ void QBluetoothSocket::setSocketError(QBluetoothSocket::SocketError error_)
 
 void QBluetoothSocket::doDeviceDiscovery(const QBluetoothServiceInfo &service, OpenMode openMode)
 {
-    Q_D(QBluetoothSocket);
+    Q_D(QBluetoothSocketBase);
 
     setSocketState(QBluetoothSocket::ServiceLookupState);
-    qCDebug(QT_BT) << "Starting Bluetooth Socket discovery";
+    qCDebug(QT_BT) << "Starting Bluetooth service discovery";
 
     if(d->discoveryAgent) {
         d->discoveryAgent->stop();
@@ -697,7 +595,7 @@ void QBluetoothSocket::doDeviceDiscovery(const QBluetoothServiceInfo &service, O
 
 void QBluetoothSocket::serviceDiscovered(const QBluetoothServiceInfo &service)
 {
-    Q_D(QBluetoothSocket);
+    Q_D(QBluetoothSocketBase);
     qCDebug(QT_BT) << "FOUND SERVICE!" << service;
     if (service.protocolServiceMultiplexer() > 0 || service.serverChannel() > 0) {
         connectToService(service, d->openMode);
@@ -711,7 +609,7 @@ void QBluetoothSocket::serviceDiscovered(const QBluetoothServiceInfo &service)
 void QBluetoothSocket::discoveryFinished()
 {
     qCDebug(QT_BT) << "Socket discovery finished";
-    Q_D(QBluetoothSocket);
+    Q_D(QBluetoothSocketBase);
     if (d->discoveryAgent){
         qCDebug(QT_BT) << "Didn't find any";
         d->errorString = tr("Service cannot be found");
@@ -727,7 +625,7 @@ void QBluetoothSocket::abort()
     if (state() == UnconnectedState)
         return;
 
-    Q_D(QBluetoothSocket);
+    Q_D(QBluetoothSocketBase);
     setOpenMode(QIODevice::NotOpen);
 
     if (state() == ServiceLookupState && d->discoveryAgent) {
@@ -742,6 +640,7 @@ void QBluetoothSocket::abort()
 #ifndef QT_ANDROID_BLUETOOTH
     //Android closes when the Java event loop comes around
     setSocketState(QBluetoothSocket::UnconnectedState);
+    emit readChannelFinished();
     emit disconnected();
 #endif
 }
@@ -753,43 +652,43 @@ void QBluetoothSocket::disconnectFromService()
 
 QString QBluetoothSocket::localName() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->localName();
 }
 
 QBluetoothAddress QBluetoothSocket::localAddress() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->localAddress();
 }
 
 quint16 QBluetoothSocket::localPort() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->localPort();
 }
 
 QString QBluetoothSocket::peerName() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->peerName();
 }
 
 QBluetoothAddress QBluetoothSocket::peerAddress() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->peerAddress();
 }
 
 quint16 QBluetoothSocket::peerPort() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->peerPort();
 }
 
 qint64 QBluetoothSocket::writeData(const char *data, qint64 maxSize)
 {
-    Q_D(QBluetoothSocket);
+    Q_D(QBluetoothSocketBase);
 
     if (!data || maxSize <= 0) {
         d_ptr->errorString = tr("Invalid data/data size");
@@ -802,7 +701,7 @@ qint64 QBluetoothSocket::writeData(const char *data, qint64 maxSize)
 
 qint64 QBluetoothSocket::readData(char *data, qint64 maxSize)
 {
-    Q_D(QBluetoothSocket);
+    Q_D(QBluetoothSocketBase);
     return d->readData(data, maxSize);
 }
 
@@ -811,7 +710,7 @@ void QBluetoothSocket::close()
     if (state() == UnconnectedState)
         return;
 
-    Q_D(QBluetoothSocket);
+    Q_D(QBluetoothSocketBase);
     setOpenMode(QIODevice::NotOpen);
 
     if (state() == ServiceLookupState && d->discoveryAgent) {
@@ -827,6 +726,7 @@ void QBluetoothSocket::close()
 #ifndef QT_ANDROID_BLUETOOTH
     //Android closes when the Java event loop comes around
     setSocketState(UnconnectedState);
+    emit readChannelFinished();
     emit disconnected();
 #endif
 }
@@ -842,7 +742,7 @@ void QBluetoothSocket::close()
 bool QBluetoothSocket::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
                                            SocketState socketState, OpenMode openMode)
 {
-    Q_D(QBluetoothSocket);
+    Q_D(QBluetoothSocketBase);
     return d->setSocketDescriptor(socketDescriptor, socketType, socketState, openMode);
 }
 
@@ -853,7 +753,7 @@ bool QBluetoothSocket::setSocketDescriptor(int socketDescriptor, QBluetoothServi
 
 int QBluetoothSocket::socketDescriptor() const
 {
-    Q_D(const QBluetoothSocket);
+    Q_D(const QBluetoothSocketBase);
     return d->socket;
 }
 
diff --git a/src/bluetooth/qbluetoothsocket.h b/src/bluetooth/qbluetoothsocket.h
index db8562ed..cda64dff 100644
--- a/src/bluetooth/qbluetoothsocket.h
+++ b/src/bluetooth/qbluetoothsocket.h
@@ -52,15 +52,30 @@
 
 QT_BEGIN_NAMESPACE
 
+#ifndef QT_OSX_BLUETOOTH
+class QBluetoothSocketBasePrivate;
+#else
 class QBluetoothSocketPrivate;
+#endif
 
 class Q_BLUETOOTH_EXPORT QBluetoothSocket : public QIODevice
 {
     Q_OBJECT
+#ifndef QT_OSX_BLUETOOTH
+    Q_DECLARE_PRIVATE(QBluetoothSocketBase)
+#else
     Q_DECLARE_PRIVATE(QBluetoothSocket)
+#endif
+
 
     friend class QBluetoothServer;
     friend class QBluetoothServerPrivate;
+    friend class QBluetoothSocketPrivate;
+    friend class QBluetoothSocketPrivateAndroid;
+    friend class QBluetoothSocketPrivateBluez;
+    friend class QBluetoothSocketPrivateBluezDBus;
+    friend class QBluetoothSocketPrivateDummy;
+    friend class QBluetoothSocketPrivateWinRT;
 
 public:
 
@@ -107,9 +122,9 @@ public:
     void connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid, OpenMode openMode = ReadWrite);
     void connectToService(const QBluetoothAddress &address, quint16 port, OpenMode openMode = ReadWrite);
     inline void connectToService(const QBluetoothAddress &address, QBluetoothUuid::ServiceClassUuid uuid,
-                                 OpenMode openMode = ReadWrite)
+                                 OpenMode mode = ReadWrite)
     {
-        connectToService(address, QBluetoothUuid(uuid), openMode);
+        connectToService(address, QBluetoothUuid(uuid), mode);
     }
     void disconnectFromService();
 
@@ -166,7 +181,11 @@ private Q_SLOTS:
 
 
 protected:
+#ifndef QT_OSX_BLUETOOTH
+    QBluetoothSocketBasePrivate *d_ptr;
+#else
     QBluetoothSocketPrivate *d_ptr;
+#endif
 
 private:
     friend class QLowEnergyControllerPrivateBluez;
diff --git a/src/bluetooth/qbluetoothsocket_android.cpp b/src/bluetooth/qbluetoothsocket_android.cpp
index d0b901ae..9047bb31 100644
--- a/src/bluetooth/qbluetoothsocket_android.cpp
+++ b/src/bluetooth/qbluetoothsocket_android.cpp
@@ -39,8 +39,10 @@
 ****************************************************************************/
 
 #include "qbluetoothsocket.h"
-#include "qbluetoothsocket_p.h"
+#include "qbluetoothsocket_android_p.h"
 #include "qbluetoothaddress.h"
+#include "qbluetoothdeviceinfo.h"
+#include "qbluetoothserviceinfo.h"
 #include <QtCore/QLoggingCategory>
 #include <QtCore/QThread>
 #include <QtCore/QTime>
@@ -148,8 +150,8 @@ public:
     {
     }
 
-    // Runs in same thread as QBluetoothSocketPrivate
-    void setupWorker(QBluetoothSocketPrivate* d_ptr, const QAndroidJniObject& socketObject,
+    // Runs in same thread as QBluetoothSocketPrivateAndroid
+    void setupWorker(QBluetoothSocketPrivateAndroid* d_ptr, const QAndroidJniObject& socketObject,
                      const QAndroidJniObject& uuidObject, bool useFallback,
                      const QBluetoothUuid& qtUuid = QBluetoothUuid())
     {
@@ -159,18 +161,18 @@ public:
 
         connect(this, &QThread::finished, worker, &QObject::deleteLater);
         connect(this, &QThread::finished, this, &QObject::deleteLater);
-        connect(d_ptr, &QBluetoothSocketPrivate::connectJavaSocket,
+        connect(d_ptr, &QBluetoothSocketPrivateAndroid::connectJavaSocket,
                 worker, &SocketConnectWorker::connectSocket);
-        connect(d_ptr, &QBluetoothSocketPrivate::closeJavaSocket,
+        connect(d_ptr, &QBluetoothSocketPrivateAndroid::closeJavaSocket,
                 worker, &SocketConnectWorker::closeSocket);
         connect(worker, &SocketConnectWorker::socketConnectDone,
-                d_ptr, &QBluetoothSocketPrivate::socketConnectSuccess);
+                d_ptr, &QBluetoothSocketPrivateAndroid::socketConnectSuccess);
         if (useFallback) {
             connect(worker, &SocketConnectWorker::socketConnectFailed,
-                    d_ptr, &QBluetoothSocketPrivate::fallbackSocketConnectFailed);
+                    d_ptr, &QBluetoothSocketPrivateAndroid::fallbackSocketConnectFailed);
         } else {
             connect(worker, &SocketConnectWorker::socketConnectFailed,
-                d_ptr, &QBluetoothSocketPrivate::defaultSocketConnectFailed);
+                d_ptr, &QBluetoothSocketPrivateAndroid::defaultSocketConnectFailed);
         }
 
         workerPointer = worker;
@@ -204,16 +206,11 @@ static QBluetoothUuid reverseUuid(const QBluetoothUuid &serviceUuid)
     return QBluetoothUuid(reversed);
 }
 
-QBluetoothSocketPrivate::QBluetoothSocketPrivate()
-  : socket(-1),
-    socketType(QBluetoothServiceInfo::UnknownProtocol),
-    state(QBluetoothSocket::UnconnectedState),
-    socketError(QBluetoothSocket::NoSocketError),
-    connecting(false),
-    discoveryAgent(0),
-    secFlags(QBluetooth::Secure),
+QBluetoothSocketPrivateAndroid::QBluetoothSocketPrivateAndroid()
+  :
     inputThread(0)
 {
+    secFlags = QBluetooth::Secure;
     adapter = QAndroidJniObject::callStaticObjectMethod("android/bluetooth/BluetoothAdapter",
                                                         "getDefaultAdapter",
                                                         "()Landroid/bluetooth/BluetoothAdapter;");
@@ -221,13 +218,13 @@ QBluetoothSocketPrivate::QBluetoothSocketPrivate()
     qRegisterMetaType<QBluetoothSocket::SocketState>();
 }
 
-QBluetoothSocketPrivate::~QBluetoothSocketPrivate()
+QBluetoothSocketPrivateAndroid::~QBluetoothSocketPrivateAndroid()
 {
     if (state != QBluetoothSocket::UnconnectedState)
         emit closeJavaSocket();
 }
 
-bool QBluetoothSocketPrivate::ensureNativeSocket(QBluetoothServiceInfo::Protocol type)
+bool QBluetoothSocketPrivateAndroid::ensureNativeSocket(QBluetoothServiceInfo::Protocol type)
 {
     socketType = type;
     if (socketType == QBluetoothServiceInfo::RfcommProtocol)
@@ -236,7 +233,7 @@ bool QBluetoothSocketPrivate::ensureNativeSocket(QBluetoothServiceInfo::Protocol
     return false;
 }
 
-bool QBluetoothSocketPrivate::fallBackConnect(QAndroidJniObject uuid, int channel)
+bool QBluetoothSocketPrivateAndroid::fallBackConnect(QAndroidJniObject uuid, int channel)
 {
     qCWarning(QT_BT_ANDROID) << "Falling back to getServiceChannel() workaround.";
 
@@ -355,7 +352,7 @@ bool QBluetoothSocketPrivate::fallBackConnect(QAndroidJniObject uuid, int channe
 /*
  * Workaround for QTBUG-61392
  */
-bool QBluetoothSocketPrivate::fallBackReversedConnect(const QBluetoothUuid &uuid)
+bool QBluetoothSocketPrivateAndroid::fallBackReversedConnect(const QBluetoothUuid &uuid)
 {
     Q_Q(QBluetoothSocket);
 
@@ -408,31 +405,31 @@ bool QBluetoothSocketPrivate::fallBackReversedConnect(const QBluetoothUuid &uuid
 }
 
 /*
- * The call order during a connectToService() is as follows:
+ * The call order during a connectToServiceHelper() is as follows:
  *
- * 1. call connectToService()
+ * 1. call connectToServiceHelper()
  * 2. wait for execution of SocketConnectThread::run()
  * 3. if threaded connect succeeds call socketConnectSuccess() via signals
  *      -> done
  * 4. if threaded connect fails call defaultSocketConnectFailed() via signals
  * 5. call fallBackConnect() if Android version 22 or below
- *     -> Android 23+ complete failure of entire connectToService()
+ *     -> Android 23+ complete failure of entire connectToServiceHelper()
  * 6. call fallBackReversedConnect() if Android version 23 or above
- *     -> if failure entire connectToService() fails
+ *     -> if failure entire connectToServiceHelper() fails
  * 7. if threaded connect on one of above fallbacks succeeds call socketConnectSuccess()
  *    via signals
  *      -> done
  * 8. if threaded connect on fallback channel fails call fallbackSocketConnectFailed()
- *      -> complete failure of entire connectToService()
+ *      -> complete failure of entire connectToServiceHelper()
  * */
-void QBluetoothSocketPrivate::connectToService(const QBluetoothAddress &address,
+void QBluetoothSocketPrivateAndroid::connectToServiceHelper(const QBluetoothAddress &address,
                                                const QBluetoothUuid &uuid,
                                                QIODevice::OpenMode openMode)
 {
     Q_Q(QBluetoothSocket);
     Q_UNUSED(openMode);
 
-    qCDebug(QT_BT_ANDROID) << "connectToService()" << address.toString() << uuid.toString();
+    qCDebug(QT_BT_ANDROID) << "connectToServiceHelper()" << address.toString() << uuid.toString();
 
     q->setSocketState(QBluetoothSocket::ConnectingState);
 
@@ -508,7 +505,71 @@ void QBluetoothSocketPrivate::connectToService(const QBluetoothAddress &address,
     emit connectJavaSocket();
 }
 
-void QBluetoothSocketPrivate::socketConnectSuccess(const QAndroidJniObject &socket)
+void QBluetoothSocketPrivateAndroid::connectToService(
+        const QBluetoothServiceInfo &service, QIODevice::OpenMode openMode)
+{
+    Q_Q(QBluetoothSocket);
+
+    if (q->state() != QBluetoothSocket::UnconnectedState
+            && q->state() != QBluetoothSocket::ServiceLookupState) {
+        qCWarning(QT_BT_ANDROID) << "QBluetoothSocketPrivateAndroid::connectToService called on busy socket";
+        errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
+        q->setSocketError(QBluetoothSocket::OperationError);
+        return;
+    }
+
+    if (!ensureNativeSocket(service.socketProtocol())) {
+        errorString = QBluetoothSocket::tr("Socket type not supported");
+        q->setSocketError(QBluetoothSocket::UnsupportedProtocolError);
+        return;
+    }
+    connectToServiceHelper(service.device().address(), service.serviceUuid(), openMode);
+}
+
+void QBluetoothSocketPrivateAndroid::connectToService(
+        const QBluetoothAddress &address, const QBluetoothUuid &uuid,
+        QIODevice::OpenMode openMode)
+{
+    Q_Q(QBluetoothSocket);
+
+    if (q->state() != QBluetoothSocket::UnconnectedState) {
+        qCWarning(QT_BT_ANDROID) << "QBluetoothSocketPrivateAndroid::connectToService called on busy socket";
+        errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
+        q->setSocketError(QBluetoothSocket::OperationError);
+        return;
+    }
+
+    if (q->socketType() == QBluetoothServiceInfo::UnknownProtocol) {
+        qCWarning(QT_BT_ANDROID) << "QBluetoothSocketPrivateAndroid::connectToService cannot "
+                                  "connect with 'UnknownProtocol' (type provided by given service)";
+        errorString = QBluetoothSocket::tr("Socket type not supported");
+        q->setSocketError(QBluetoothSocket::UnsupportedProtocolError);
+        return;
+    }
+
+    if (!ensureNativeSocket(q->socketType())) {
+        errorString = QBluetoothSocket::tr("Socket type not supported");
+        q->setSocketError(QBluetoothSocket::UnsupportedProtocolError);
+        return;
+    }
+    connectToServiceHelper(address, uuid, openMode);
+}
+
+void QBluetoothSocketPrivateAndroid::connectToService(
+        const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
+{
+    Q_UNUSED(port);
+    Q_UNUSED(openMode);
+    Q_UNUSED(address);
+
+    Q_Q(QBluetoothSocket);
+
+    errorString = tr("Connecting to port is not supported");
+    q->setSocketError(QBluetoothSocket::ServiceNotFoundError);
+    qCWarning(QT_BT_ANDROID) << "Connecting to port is not supported";
+}
+
+void QBluetoothSocketPrivateAndroid::socketConnectSuccess(const QAndroidJniObject &socket)
 {
     Q_Q(QBluetoothSocket);
     QAndroidJniEnvironment env;
@@ -568,7 +629,7 @@ void QBluetoothSocketPrivate::socketConnectSuccess(const QAndroidJniObject &sock
     emit q->connected();
 }
 
-void QBluetoothSocketPrivate::defaultSocketConnectFailed(
+void QBluetoothSocketPrivateAndroid::defaultSocketConnectFailed(
         const QAndroidJniObject &socket, const QAndroidJniObject &targetUuid,
         const QBluetoothUuid &qtTargetUuid)
 {
@@ -597,7 +658,7 @@ void QBluetoothSocketPrivate::defaultSocketConnectFailed(
     }
 }
 
-void QBluetoothSocketPrivate::fallbackSocketConnectFailed(
+void QBluetoothSocketPrivateAndroid::fallbackSocketConnectFailed(
         const QAndroidJniObject &socket, const QAndroidJniObject &targetUuid)
 {
     Q_UNUSED(targetUuid);
@@ -616,7 +677,7 @@ void QBluetoothSocketPrivate::fallbackSocketConnectFailed(
     q->setSocketState(QBluetoothSocket::UnconnectedState);
 }
 
-void QBluetoothSocketPrivate::abort()
+void QBluetoothSocketPrivateAndroid::abort()
 {
     if (state == QBluetoothSocket::UnconnectedState)
         return;
@@ -629,7 +690,7 @@ void QBluetoothSocketPrivate::abort()
          * thread because inputStream.read() throws IOException
          * In turn the thread stops and throws an error which sets
          * new state, error and emits relevant signals.
-         * See QBluetoothSocketPrivate::inputThreadError() for details
+         * See QBluetoothSocketPrivateAndroid::inputThreadError() for details
          */
 
         if (inputThread)
@@ -658,7 +719,7 @@ void QBluetoothSocketPrivate::abort()
     }
 }
 
-QString QBluetoothSocketPrivate::localName() const
+QString QBluetoothSocketPrivateAndroid::localName() const
 {
     if (adapter.isValid())
         return adapter.callObjectMethod<jstring>("getName").toString();
@@ -666,7 +727,7 @@ QString QBluetoothSocketPrivate::localName() const
     return QString();
 }
 
-QBluetoothAddress QBluetoothSocketPrivate::localAddress() const
+QBluetoothAddress QBluetoothSocketPrivateAndroid::localAddress() const
 {
     QString result;
     if (adapter.isValid())
@@ -675,13 +736,13 @@ QBluetoothAddress QBluetoothSocketPrivate::localAddress() const
     return QBluetoothAddress(result);
 }
 
-quint16 QBluetoothSocketPrivate::localPort() const
+quint16 QBluetoothSocketPrivateAndroid::localPort() const
 {
     // Impossible to get channel number with current Android API (Levels 5 to 19)
     return 0;
 }
 
-QString QBluetoothSocketPrivate::peerName() const
+QString QBluetoothSocketPrivateAndroid::peerName() const
 {
     if (!remoteDevice.isValid())
         return QString();
@@ -689,7 +750,7 @@ QString QBluetoothSocketPrivate::peerName() const
     return remoteDevice.callObjectMethod("getName", "()Ljava/lang/String;").toString();
 }
 
-QBluetoothAddress QBluetoothSocketPrivate::peerAddress() const
+QBluetoothAddress QBluetoothSocketPrivateAndroid::peerAddress() const
 {
     if (!remoteDevice.isValid())
         return QBluetoothAddress();
@@ -700,13 +761,13 @@ QBluetoothAddress QBluetoothSocketPrivate::peerAddress() const
     return QBluetoothAddress(address);
 }
 
-quint16 QBluetoothSocketPrivate::peerPort() const
+quint16 QBluetoothSocketPrivateAndroid::peerPort() const
 {
     // Impossible to get channel number with current Android API (Levels 5 to 13)
     return 0;
 }
 
-qint64 QBluetoothSocketPrivate::writeData(const char *data, qint64 maxSize)
+qint64 QBluetoothSocketPrivateAndroid::writeData(const char *data, qint64 maxSize)
 {
     //TODO implement buffered behavior (so far only unbuffered)
     Q_Q(QBluetoothSocket);
@@ -736,7 +797,7 @@ qint64 QBluetoothSocketPrivate::writeData(const char *data, qint64 maxSize)
     return maxSize;
 }
 
-qint64 QBluetoothSocketPrivate::readData(char *data, qint64 maxSize)
+qint64 QBluetoothSocketPrivateAndroid::readData(char *data, qint64 maxSize)
 {
     Q_Q(QBluetoothSocket);
     if (state != QBluetoothSocket::ConnectedState || !inputThread) {
@@ -749,7 +810,7 @@ qint64 QBluetoothSocketPrivate::readData(char *data, qint64 maxSize)
     return inputThread->readData(data, maxSize);
 }
 
-void QBluetoothSocketPrivate::inputThreadError(int errorCode)
+void QBluetoothSocketPrivateAndroid::inputThreadError(int errorCode)
 {
     Q_Q(QBluetoothSocket);
 
@@ -779,10 +840,11 @@ void QBluetoothSocketPrivate::inputThreadError(int errorCode)
 
     q->setSocketState(QBluetoothSocket::UnconnectedState);
     q->setOpenMode(QIODevice::NotOpen);
+    emit q->readChannelFinished();
     emit q->disconnected();
 }
 
-void QBluetoothSocketPrivate::close()
+void QBluetoothSocketPrivateAndroid::close()
 {
     /* This function is called by QBluetoothSocket::close and softer version
        QBluetoothSocket::disconnectFromService() which difference I do not quite fully understand.
@@ -791,7 +853,7 @@ void QBluetoothSocketPrivate::close()
     abort();
 }
 
-bool QBluetoothSocketPrivate::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
+bool QBluetoothSocketPrivateAndroid::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
                          QBluetoothSocket::SocketState socketState, QBluetoothSocket::OpenMode openMode)
 {
     Q_UNUSED(socketDescriptor);
@@ -802,7 +864,7 @@ bool QBluetoothSocketPrivate::setSocketDescriptor(int socketDescriptor, QBluetoo
     return false;
 }
 
-bool QBluetoothSocketPrivate::setSocketDescriptor(const QAndroidJniObject &socket, QBluetoothServiceInfo::Protocol socketType_,
+bool QBluetoothSocketPrivateAndroid::setSocketDescriptor(const QAndroidJniObject &socket, QBluetoothServiceInfo::Protocol socketType_,
                          QBluetoothSocket::SocketState socketState, QBluetoothSocket::OpenMode openMode)
 {
     Q_Q(QBluetoothSocket);
@@ -870,7 +932,7 @@ bool QBluetoothSocketPrivate::setSocketDescriptor(const QAndroidJniObject &socke
     return true;
 }
 
-qint64 QBluetoothSocketPrivate::bytesAvailable() const
+qint64 QBluetoothSocketPrivateAndroid::bytesAvailable() const
 {
     //We cannot access buffer directly as it is part of different thread
     if (inputThread)
@@ -879,12 +941,12 @@ qint64 QBluetoothSocketPrivate::bytesAvailable() const
     return 0;
 }
 
-qint64 QBluetoothSocketPrivate::bytesToWrite() const
+qint64 QBluetoothSocketPrivateAndroid::bytesToWrite() const
 {
     return 0; // nothing because always unbuffered
 }
 
-bool QBluetoothSocketPrivate::canReadLine() const
+bool QBluetoothSocketPrivateAndroid::canReadLine() const
 {
     // We cannot access buffer directly as it is part of different thread
     if (inputThread)
diff --git a/src/bluetooth/qbluetoothsocket_android_p.h b/src/bluetooth/qbluetoothsocket_android_p.h
new file mode 100644
index 00000000..7bf42e32
--- /dev/null
+++ b/src/bluetooth/qbluetoothsocket_android_p.h
@@ -0,0 +1,145 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 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 QBLUETOOTHSOCKET_ANDROID_P_H
+#define QBLUETOOTHSOCKET_ANDROID_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 "qbluetoothsocketbase_p.h"
+
+#include <QtAndroidExtras/QAndroidJniObject>
+#include <QtCore/QPointer>
+#include "android/inputstreamthread_p.h"
+#include <jni.h>
+
+QT_BEGIN_NAMESPACE
+
+class QBluetoothSocketPrivateAndroid final : public QBluetoothSocketBasePrivate
+{
+    Q_OBJECT
+    friend class QBluetoothServerPrivate;
+
+public:
+    QBluetoothSocketPrivateAndroid();
+    ~QBluetoothSocketPrivateAndroid() override;
+
+    //On Android we connect using the uuid not the port
+    void connectToServiceHelper(const QBluetoothAddress &address, const QBluetoothUuid &uuid,
+                          QIODevice::OpenMode openMode) override;
+
+    void connectToService(const QBluetoothServiceInfo &service,
+                          QIODevice::OpenMode openMode) override;
+    void connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid,
+                          QIODevice::OpenMode openMode) override;
+    void connectToService(const QBluetoothAddress &address, quint16 port,
+                          QIODevice::OpenMode openMode) override;
+
+    bool fallBackConnect(QAndroidJniObject uuid, int channel);
+    bool fallBackReversedConnect(const QBluetoothUuid &uuid);
+
+    bool ensureNativeSocket(QBluetoothServiceInfo::Protocol type) override;
+
+    QString localName() const override;
+    QBluetoothAddress localAddress() const override;
+    quint16 localPort() const override;
+
+    QString peerName() const override;
+    QBluetoothAddress peerAddress() const override;
+    quint16 peerPort() const override;
+
+    void abort() override;
+    void close() override;
+
+    qint64 writeData(const char *data, qint64 maxSize) override;
+    qint64 readData(char *data, qint64 maxSize) override;
+
+    bool setSocketDescriptor(const QAndroidJniObject &socket, QBluetoothServiceInfo::Protocol socketType,
+                             QBluetoothSocket::SocketState socketState = QBluetoothSocket::ConnectedState,
+                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite) override;
+
+    bool setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
+                             QBluetoothSocket::SocketState socketState = QBluetoothSocket::ConnectedState,
+                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite) override;
+
+    qint64 bytesAvailable() const override;
+    bool canReadLine() const override;
+    qint64 bytesToWrite() const override;
+
+    QAndroidJniObject adapter;
+    QAndroidJniObject socketObject;
+    QAndroidJniObject remoteDevice;
+    QAndroidJniObject inputStream;
+    QAndroidJniObject outputStream;
+    InputStreamThread *inputThread;
+
+public slots:
+    void socketConnectSuccess(const QAndroidJniObject &socket);
+    void defaultSocketConnectFailed(const QAndroidJniObject & socket,
+                                    const QAndroidJniObject &targetUuid,
+                                    const QBluetoothUuid &qtTargetUuid);
+    void fallbackSocketConnectFailed(const QAndroidJniObject &socket,
+                                     const QAndroidJniObject &targetUuid);
+    void inputThreadError(int errorCode);
+
+signals:
+    void connectJavaSocket();
+    void closeJavaSocket();
+
+};
+
+// QTBUG-61392 related
+// Private API to disable the silent behavior to reverse a remote service's
+// UUID. In rare cases the workaround behavior might not be desirable as
+// it may lead to connects to incorrect services.
+extern bool useReverseUuidWorkAroundConnect;
+
+QT_END_NAMESPACE
+
+#endif // QBLUETOOTHSOCKET_ANDROID_P_H
diff --git a/src/bluetooth/qbluetoothsocket_bluez.cpp b/src/bluetooth/qbluetoothsocket_bluez.cpp
index 17b8e738..ccf34e7b 100644
--- a/src/bluetooth/qbluetoothsocket_bluez.cpp
+++ b/src/bluetooth/qbluetoothsocket_bluez.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2018 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtBluetooth module of the Qt Toolkit.
@@ -38,7 +38,8 @@
 ****************************************************************************/
 
 #include "qbluetoothsocket.h"
-#include "qbluetoothsocket_p.h"
+#include "qbluetoothsocket_bluez_p.h"
+#include "qbluetoothdeviceinfo.h"
 
 #include "bluez/manager_p.h"
 #include "bluez/adapter_p.h"
@@ -62,38 +63,30 @@ QT_BEGIN_NAMESPACE
 
 Q_DECLARE_LOGGING_CATEGORY(QT_BT_BLUEZ)
 
-QBluetoothSocketPrivate::QBluetoothSocketPrivate()
-    : socket(-1),
-      socketType(QBluetoothServiceInfo::UnknownProtocol),
-      state(QBluetoothSocket::UnconnectedState),
-      socketError(QBluetoothSocket::NoSocketError),
-      readNotifier(0),
-      connectWriteNotifier(0),
-      connecting(false),
-      discoveryAgent(0),
-      secFlags(QBluetooth::Authorization),
-      lowEnergySocketType(0)
+QBluetoothSocketPrivateBluez::QBluetoothSocketPrivateBluez()
+    : QBluetoothSocketBasePrivate()
 {
+    secFlags = QBluetooth::Authorization;
 }
 
-QBluetoothSocketPrivate::~QBluetoothSocketPrivate()
+QBluetoothSocketPrivateBluez::~QBluetoothSocketPrivateBluez()
 {
     delete readNotifier;
-    readNotifier = 0;
+    readNotifier = nullptr;
     delete connectWriteNotifier;
-    connectWriteNotifier = 0;
+    connectWriteNotifier = nullptr;
 }
 
-bool QBluetoothSocketPrivate::ensureNativeSocket(QBluetoothServiceInfo::Protocol type)
+bool QBluetoothSocketPrivateBluez::ensureNativeSocket(QBluetoothServiceInfo::Protocol type)
 {
     if (socket != -1) {
         if (socketType == type)
             return true;
 
         delete readNotifier;
-        readNotifier = 0;
+        readNotifier = nullptr;
         delete connectWriteNotifier;
-        connectWriteNotifier = 0;
+        connectWriteNotifier = nullptr;
         QT_CLOSE(socket);
     }
 
@@ -129,7 +122,7 @@ bool QBluetoothSocketPrivate::ensureNativeSocket(QBluetoothServiceInfo::Protocol
     return true;
 }
 
-void QBluetoothSocketPrivate::connectToService(const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
+void QBluetoothSocketPrivateBluez::connectToServiceHelper(const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
 {
     Q_Q(QBluetoothSocket);
     int result = -1;
@@ -214,7 +207,111 @@ void QBluetoothSocketPrivate::connectToService(const QBluetoothAddress &address,
     }
 }
 
-void QBluetoothSocketPrivate::_q_writeNotify()
+void QBluetoothSocketPrivateBluez::connectToService(
+        const QBluetoothServiceInfo &service, QIODevice::OpenMode openMode)
+{
+    Q_Q(QBluetoothSocket);
+
+    if (q->state() != QBluetoothSocket::UnconnectedState
+            && q->state() != QBluetoothSocket::ServiceLookupState) {
+        qCWarning(QT_BT_BLUEZ) << "QBluetoothSocketPrivateBluez::connectToService called on busy socket";
+        errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
+        q->setSocketError(QBluetoothSocket::OperationError);
+        return;
+    }
+
+    // we are checking the service protocol and not socketType()
+    // socketType will change in ensureNativeSocket()
+    if (service.socketProtocol() == QBluetoothServiceInfo::UnknownProtocol) {
+        qCWarning(QT_BT_BLUEZ) << "QBluetoothSocket::connectToService cannot "
+                                  "connect with 'UnknownProtocol' (type provided by given service)";
+        errorString = QBluetoothSocket::tr("Socket type not supported");
+        q->setSocketError(QBluetoothSocket::UnsupportedProtocolError);
+        return;
+    }
+
+    if (service.protocolServiceMultiplexer() > 0) {
+        Q_ASSERT(service.socketProtocol() == QBluetoothServiceInfo::L2capProtocol);
+
+        if (!ensureNativeSocket(QBluetoothServiceInfo::L2capProtocol)) {
+            errorString = QBluetoothSocket::tr("Unknown socket error");
+            q->setSocketError(QBluetoothSocket::UnknownSocketError);
+            return;
+        }
+        connectToServiceHelper(service.device().address(), service.protocolServiceMultiplexer(),
+                               openMode);
+    } else if (service.serverChannel() > 0) {
+        Q_ASSERT(service.socketProtocol() == QBluetoothServiceInfo::RfcommProtocol);
+
+        if (!ensureNativeSocket(QBluetoothServiceInfo::RfcommProtocol)) {
+            errorString = QBluetoothSocket::tr("Unknown socket error");
+            q->setSocketError(QBluetoothSocket::UnknownSocketError);
+            return;
+        }
+        connectToServiceHelper(service.device().address(), service.serverChannel(), openMode);
+    } else {
+        // try doing service discovery to see if we can find the socket
+        if (service.serviceUuid().isNull()
+                && !service.serviceClassUuids().contains(QBluetoothUuid::SerialPort)) {
+            qCWarning(QT_BT_BLUEZ) << "No port, no PSM, and no UUID provided. Unable to connect";
+            return;
+        }
+        qCDebug(QT_BT_BLUEZ) << "Need a port/psm, doing discovery";
+        q->doDeviceDiscovery(service, openMode);
+    }
+}
+
+void QBluetoothSocketPrivateBluez::connectToService(
+        const QBluetoothAddress &address, const QBluetoothUuid &uuid,
+        QIODevice::OpenMode openMode)
+{
+    Q_Q(QBluetoothSocket);
+
+    if (q->state() != QBluetoothSocket::UnconnectedState) {
+        qCWarning(QT_BT_BLUEZ) << "QBluetoothSocketPrivateBluez::connectToService called on busy socket";
+        errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
+        q->setSocketError(QBluetoothSocket::OperationError);
+        return;
+    }
+
+    if (q->socketType() == QBluetoothServiceInfo::UnknownProtocol) {
+        qCWarning(QT_BT_BLUEZ) << "QBluetoothSocketPrivateBluez::connectToService cannot "
+                                  "connect with 'UnknownProtocol' (type provided by given service)";
+        errorString = QBluetoothSocket::tr("Socket type not supported");
+        q->setSocketError(QBluetoothSocket::UnsupportedProtocolError);
+        return;
+    }
+
+    QBluetoothServiceInfo service;
+    QBluetoothDeviceInfo device(address, QString(), QBluetoothDeviceInfo::MiscellaneousDevice);
+    service.setDevice(device);
+    service.setServiceUuid(uuid);
+    q->doDeviceDiscovery(service, openMode);
+}
+
+void QBluetoothSocketPrivateBluez::connectToService(
+        const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
+{
+    Q_Q(QBluetoothSocket);
+
+    if (q->socketType() == QBluetoothServiceInfo::UnknownProtocol) {
+        qCWarning(QT_BT_BLUEZ) << "QBluetoothSocketPrivateBluez::connectToService cannot "
+                                  "connect with 'UnknownProtocol' (type provided by given service)";
+        errorString = QBluetoothSocket::tr("Socket type not supported");
+        q->setSocketError(QBluetoothSocket::UnsupportedProtocolError);
+        return;
+    }
+
+    if (q->state() != QBluetoothSocket::UnconnectedState) {
+        qCWarning(QT_BT_BLUEZ) << "QBluetoothSocketPrivateBluez::connectToService called on busy socket";
+        errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
+        q->setSocketError(QBluetoothSocket::OperationError);
+        return;
+    }
+    connectToServiceHelper(address, port, openMode);
+}
+
+void QBluetoothSocketPrivateBluez::_q_writeNotify()
 {
     Q_Q(QBluetoothSocket);
     if(connecting && state == QBluetoothSocket::ConnectingState){
@@ -275,7 +372,7 @@ void QBluetoothSocketPrivate::_q_writeNotify()
     }
 }
 
-void QBluetoothSocketPrivate::_q_readNotify()
+void QBluetoothSocketPrivateBluez::_q_readNotify()
 {
     Q_Q(QBluetoothSocket);
     char *writePointer = buffer.reserve(QPRIVATELINEARBUFFER_BUFFERSIZE);
@@ -302,7 +399,7 @@ void QBluetoothSocketPrivate::_q_readNotify()
     }
 }
 
-void QBluetoothSocketPrivate::abort()
+void QBluetoothSocketPrivateBluez::abort()
 {
     delete readNotifier;
     readNotifier = 0;
@@ -316,7 +413,7 @@ void QBluetoothSocketPrivate::abort()
     socket = -1;
 }
 
-QString QBluetoothSocketPrivate::localName() const
+QString QBluetoothSocketPrivateBluez::localName() const
 {
     const QBluetoothAddress address = localAddress();
     if (address.isNull())
@@ -326,7 +423,7 @@ QString QBluetoothSocketPrivate::localName() const
     return device.name();
 }
 
-QBluetoothAddress QBluetoothSocketPrivate::localAddress() const
+QBluetoothAddress QBluetoothSocketPrivateBluez::localAddress() const
 {
     if (socketType == QBluetoothServiceInfo::RfcommProtocol) {
         sockaddr_rc addr;
@@ -345,7 +442,7 @@ QBluetoothAddress QBluetoothSocketPrivate::localAddress() const
     return QBluetoothAddress();
 }
 
-quint16 QBluetoothSocketPrivate::localPort() const
+quint16 QBluetoothSocketPrivateBluez::localPort() const
 {
     if (socketType == QBluetoothServiceInfo::RfcommProtocol) {
         sockaddr_rc addr;
@@ -364,7 +461,7 @@ quint16 QBluetoothSocketPrivate::localPort() const
     return 0;
 }
 
-QString QBluetoothSocketPrivate::peerName() const
+QString QBluetoothSocketPrivateBluez::peerName() const
 {
     quint64 bdaddr;
 
@@ -452,7 +549,7 @@ QString QBluetoothSocketPrivate::peerName() const
     }
 }
 
-QBluetoothAddress QBluetoothSocketPrivate::peerAddress() const
+QBluetoothAddress QBluetoothSocketPrivateBluez::peerAddress() const
 {
     if (socketType == QBluetoothServiceInfo::RfcommProtocol) {
         sockaddr_rc addr;
@@ -471,7 +568,7 @@ QBluetoothAddress QBluetoothSocketPrivate::peerAddress() const
     return QBluetoothAddress();
 }
 
-quint16 QBluetoothSocketPrivate::peerPort() const
+quint16 QBluetoothSocketPrivateBluez::peerPort() const
 {
     if (socketType == QBluetoothServiceInfo::RfcommProtocol) {
         sockaddr_rc addr;
@@ -490,7 +587,7 @@ quint16 QBluetoothSocketPrivate::peerPort() const
     return 0;
 }
 
-qint64 QBluetoothSocketPrivate::writeData(const char *data, qint64 maxSize)
+qint64 QBluetoothSocketPrivateBluez::writeData(const char *data, qint64 maxSize)
 {
     Q_Q(QBluetoothSocket);
 
@@ -535,7 +632,7 @@ qint64 QBluetoothSocketPrivate::writeData(const char *data, qint64 maxSize)
     }
 }
 
-qint64 QBluetoothSocketPrivate::readData(char *data, qint64 maxSize)
+qint64 QBluetoothSocketPrivateBluez::readData(char *data, qint64 maxSize)
 {
     Q_Q(QBluetoothSocket);
 
@@ -553,7 +650,7 @@ qint64 QBluetoothSocketPrivate::readData(char *data, qint64 maxSize)
     return 0;
 }
 
-void QBluetoothSocketPrivate::close()
+void QBluetoothSocketPrivateBluez::close()
 {
     if (txBuffer.size() > 0)
         connectWriteNotifier->setEnabled(true);
@@ -561,7 +658,7 @@ void QBluetoothSocketPrivate::close()
         abort();
 }
 
-bool QBluetoothSocketPrivate::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType_,
+bool QBluetoothSocketPrivateBluez::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType_,
                                            QBluetoothSocket::SocketState socketState, QBluetoothSocket::OpenMode openMode)
 {
     Q_Q(QBluetoothSocket);
@@ -589,17 +686,17 @@ bool QBluetoothSocketPrivate::setSocketDescriptor(int socketDescriptor, QBluetoo
     return true;
 }
 
-qint64 QBluetoothSocketPrivate::bytesAvailable() const
+qint64 QBluetoothSocketPrivateBluez::bytesAvailable() const
 {
     return buffer.size();
 }
 
-qint64 QBluetoothSocketPrivate::bytesToWrite() const
+qint64 QBluetoothSocketPrivateBluez::bytesToWrite() const
 {
     return txBuffer.size();
 }
 
-bool QBluetoothSocketPrivate::canReadLine() const
+bool QBluetoothSocketPrivateBluez::canReadLine() const
 {
     return buffer.canReadLine();
 }
diff --git a/src/bluetooth/qbluetoothsocket_bluez_p.h b/src/bluetooth/qbluetoothsocket_bluez_p.h
new file mode 100644
index 00000000..67c04b3d
--- /dev/null
+++ b/src/bluetooth/qbluetoothsocket_bluez_p.h
@@ -0,0 +1,108 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 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 QBLUETOOTHSOCKET_BLUEZ_H
+#define QBLUETOOTHSOCKET_BLUEZ_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 "qbluetoothsocketbase_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QBluetoothSocketPrivateBluez final: public QBluetoothSocketBasePrivate
+{
+    Q_OBJECT
+
+public:
+    QBluetoothSocketPrivateBluez();
+    ~QBluetoothSocketPrivateBluez() override;
+
+    void connectToServiceHelper(const QBluetoothAddress &address,
+                          quint16 port,
+                          QIODevice::OpenMode openMode) override;
+
+    void connectToService(const QBluetoothServiceInfo &service,
+                          QIODevice::OpenMode openMode) override;
+    void connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid,
+                          QIODevice::OpenMode openMode) override;
+    void connectToService(const QBluetoothAddress &address, quint16 port,
+                          QIODevice::OpenMode openMode) override;
+
+    bool ensureNativeSocket(QBluetoothServiceInfo::Protocol type) override;
+
+    QString localName() const override;
+    QBluetoothAddress localAddress() const override;
+    quint16 localPort() const override;
+
+    QString peerName() const override;
+    QBluetoothAddress peerAddress() const override;
+    quint16 peerPort() const override;
+
+    void abort() override;
+    void close() override;
+
+    qint64 writeData(const char *data, qint64 maxSize) override;
+    qint64 readData(char *data, qint64 maxSize) override;
+
+    bool setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
+                             QBluetoothSocket::SocketState socketState = QBluetoothSocket::ConnectedState,
+                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite) override;
+
+    qint64 bytesAvailable() const override;
+    bool canReadLine() const override;
+    qint64 bytesToWrite() const override;
+
+private slots:
+    void _q_readNotify();
+    void _q_writeNotify();
+};
+
+QT_END_NAMESPACE
+
+#endif // QBLUETOOTHSOCKET_BLUEZ_H
diff --git a/src/bluetooth/qbluetoothsocket_p.cpp b/src/bluetooth/qbluetoothsocket_bluezdbus.cpp
index 39d483d6..bdcc89ef 100644
--- a/src/bluetooth/qbluetoothsocket_p.cpp
+++ b/src/bluetooth/qbluetoothsocket_bluezdbus.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2018 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtBluetooth module of the Qt Toolkit.
@@ -38,77 +38,89 @@
 ****************************************************************************/
 
 #include "qbluetoothsocket.h"
-#include "qbluetoothsocket_p.h"
-#ifndef QT_IOS_BLUETOOTH
-#include "dummy/dummy_helper_p.h"
-#endif
+#include "qbluetoothsocket_bluezdbus_p.h"
 
 QT_BEGIN_NAMESPACE
-
-QBluetoothSocketPrivate::QBluetoothSocketPrivate()
-    : socket(-1),
-      socketType(QBluetoothServiceInfo::UnknownProtocol),
-      state(QBluetoothSocket::UnconnectedState),
-      socketError(QBluetoothSocket::NoSocketError),
-      secFlags(QBluetooth::NoSecurity)
+QBluetoothSocketPrivateBluezDBus::QBluetoothSocketPrivateBluezDBus()
 {
-#ifndef QT_IOS_BLUETOOTH
-    printDummyWarning();
-#endif
+    secFlags = QBluetooth::NoSecurity;
 }
 
-QBluetoothSocketPrivate::~QBluetoothSocketPrivate()
+QBluetoothSocketPrivateBluezDBus::~QBluetoothSocketPrivateBluezDBus()
 {
 }
 
-bool QBluetoothSocketPrivate::ensureNativeSocket(QBluetoothServiceInfo::Protocol type)
+bool QBluetoothSocketPrivateBluezDBus::ensureNativeSocket(QBluetoothServiceInfo::Protocol type)
 {
     socketType = type;
     return false;
 }
 
-void QBluetoothSocketPrivate::connectToService(const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
+void QBluetoothSocketPrivateBluezDBus::connectToServiceHelper(const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
 {
     Q_UNUSED(openMode);
     Q_UNUSED(address);
     Q_UNUSED(port);
 }
 
-void QBluetoothSocketPrivate::abort()
+void QBluetoothSocketPrivateBluezDBus::connectToService(
+        const QBluetoothServiceInfo &service, QIODevice::OpenMode openMode)
 {
+    Q_UNUSED(openMode);
+    Q_UNUSED(service);
 }
 
-QString QBluetoothSocketPrivate::localName() const
+void QBluetoothSocketPrivateBluezDBus::connectToService(
+        const QBluetoothAddress &address, const QBluetoothUuid &uuid, QIODevice::OpenMode openMode)
+{
+    Q_UNUSED(openMode);
+    Q_UNUSED(address);
+    Q_UNUSED(uuid);
+}
+
+void QBluetoothSocketPrivateBluezDBus::connectToService(
+        const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
+{
+    Q_UNUSED(openMode);
+    Q_UNUSED(address);
+    Q_UNUSED(port);
+}
+
+void QBluetoothSocketPrivateBluezDBus::abort()
+{
+}
+
+QString QBluetoothSocketPrivateBluezDBus::localName() const
 {
     return QString();
 }
 
-QBluetoothAddress QBluetoothSocketPrivate::localAddress() const
+QBluetoothAddress QBluetoothSocketPrivateBluezDBus::localAddress() const
 {
     return QBluetoothAddress();
 }
 
-quint16 QBluetoothSocketPrivate::localPort() const
+quint16 QBluetoothSocketPrivateBluezDBus::localPort() const
 {
     return 0;
 }
 
-QString QBluetoothSocketPrivate::peerName() const
+QString QBluetoothSocketPrivateBluezDBus::peerName() const
 {
     return QString();
 }
 
-QBluetoothAddress QBluetoothSocketPrivate::peerAddress() const
+QBluetoothAddress QBluetoothSocketPrivateBluezDBus::peerAddress() const
 {
     return QBluetoothAddress();
 }
 
-quint16 QBluetoothSocketPrivate::peerPort() const
+quint16 QBluetoothSocketPrivateBluezDBus::peerPort() const
 {
     return 0;
 }
 
-qint64 QBluetoothSocketPrivate::writeData(const char *data, qint64 maxSize)
+qint64 QBluetoothSocketPrivateBluezDBus::writeData(const char *data, qint64 maxSize)
 {
     Q_UNUSED(data);
     Q_UNUSED(maxSize);
@@ -123,7 +135,7 @@ qint64 QBluetoothSocketPrivate::writeData(const char *data, qint64 maxSize)
     return -1;
 }
 
-qint64 QBluetoothSocketPrivate::readData(char *data, qint64 maxSize)
+qint64 QBluetoothSocketPrivateBluezDBus::readData(char *data, qint64 maxSize)
 {
     Q_UNUSED(data);
     Q_UNUSED(maxSize);
@@ -139,11 +151,11 @@ qint64 QBluetoothSocketPrivate::readData(char *data, qint64 maxSize)
     return -1;
 }
 
-void QBluetoothSocketPrivate::close()
+void QBluetoothSocketPrivateBluezDBus::close()
 {
 }
 
-bool QBluetoothSocketPrivate::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
+bool QBluetoothSocketPrivateBluezDBus::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
                                            QBluetoothSocket::SocketState socketState, QBluetoothSocket::OpenMode openMode)
 {
     Q_UNUSED(socketDescriptor);
@@ -153,19 +165,18 @@ bool QBluetoothSocketPrivate::setSocketDescriptor(int socketDescriptor, QBluetoo
     return false;
 }
 
-qint64 QBluetoothSocketPrivate::bytesAvailable() const
+qint64 QBluetoothSocketPrivateBluezDBus::bytesAvailable() const
 {
     return 0;
 }
 
-bool QBluetoothSocketPrivate::canReadLine() const
+bool QBluetoothSocketPrivateBluezDBus::canReadLine() const
 {
     return false;
 }
 
-qint64 QBluetoothSocketPrivate::bytesToWrite() const
+qint64 QBluetoothSocketPrivateBluezDBus::bytesToWrite() const
 {
     return 0;
 }
-
 QT_END_NAMESPACE
diff --git a/src/bluetooth/qbluetoothsocket_bluezdbus_p.h b/src/bluetooth/qbluetoothsocket_bluezdbus_p.h
new file mode 100644
index 00000000..c7279555
--- /dev/null
+++ b/src/bluetooth/qbluetoothsocket_bluezdbus_p.h
@@ -0,0 +1,104 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 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 QBLUETOOTHSOCKET_BLUEZDBUS_H
+#define QBLUETOOTHSOCKET_BLUEZDBUS_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 "qbluetoothsocketbase_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QBluetoothSocketPrivateBluezDBus final: public QBluetoothSocketBasePrivate
+{
+    Q_OBJECT
+
+public:
+    QBluetoothSocketPrivateBluezDBus();
+    ~QBluetoothSocketPrivateBluezDBus() override;
+
+    void connectToServiceHelper(const QBluetoothAddress &address,
+                          quint16 port,
+                          QIODevice::OpenMode openMode) override;
+
+    void connectToService(const QBluetoothServiceInfo &service,
+                          QIODevice::OpenMode openMode) override;
+    void connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid,
+                          QIODevice::OpenMode openMode) override;
+    void connectToService(const QBluetoothAddress &address, quint16 port,
+                          QIODevice::OpenMode openMode) override;
+
+    bool ensureNativeSocket(QBluetoothServiceInfo::Protocol type) override;
+
+    QString localName() const override;
+    QBluetoothAddress localAddress() const override;
+    quint16 localPort() const override;
+
+    QString peerName() const override;
+    QBluetoothAddress peerAddress() const override;
+    quint16 peerPort() const override;
+
+    void abort() override;
+    void close() override;
+
+    qint64 writeData(const char *data, qint64 maxSize) override;
+    qint64 readData(char *data, qint64 maxSize) override;
+
+    bool setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
+                             QBluetoothSocket::SocketState socketState = QBluetoothSocket::ConnectedState,
+                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite) override;
+
+    qint64 bytesAvailable() const override;
+    bool canReadLine() const override;
+    qint64 bytesToWrite() const override;
+};
+
+QT_END_NAMESPACE
+
+#endif // QBLUETOOTHSOCKET_BLUEZDBUS_H
diff --git a/src/bluetooth/qbluetoothsocket_dummy.cpp b/src/bluetooth/qbluetoothsocket_dummy.cpp
new file mode 100644
index 00000000..82da46c2
--- /dev/null
+++ b/src/bluetooth/qbluetoothsocket_dummy.cpp
@@ -0,0 +1,208 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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 "qbluetoothsocket.h"
+#include "qbluetoothsocket_dummy_p.h"
+#ifndef QT_IOS_BLUETOOTH
+#include "dummy/dummy_helper_p.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+QBluetoothSocketPrivateDummy::QBluetoothSocketPrivateDummy()
+{
+    secFlags = QBluetooth::NoSecurity;
+#ifndef QT_IOS_BLUETOOTH
+    printDummyWarning();
+#endif
+}
+
+QBluetoothSocketPrivateDummy::~QBluetoothSocketPrivateDummy()
+{
+}
+
+bool QBluetoothSocketPrivateDummy::ensureNativeSocket(QBluetoothServiceInfo::Protocol type)
+{
+    socketType = type;
+    return false;
+}
+
+void QBluetoothSocketPrivateDummy::connectToServiceHelper(const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
+{
+    Q_UNUSED(openMode);
+    Q_UNUSED(address);
+    Q_UNUSED(port);
+}
+
+void QBluetoothSocketPrivateDummy::connectToService(
+        const QBluetoothServiceInfo &service, QIODevice::OpenMode openMode)
+{
+    Q_UNUSED(service);
+    Q_UNUSED(openMode);
+
+    Q_Q(QBluetoothSocket);
+
+    qWarning() << "Using non-functional QBluetoothSocketPrivateDummy";
+    errorString = QBluetoothSocket::tr("Socket type not supported");
+    q->setSocketError(QBluetoothSocket::UnsupportedProtocolError);
+}
+
+void QBluetoothSocketPrivateDummy::connectToService(
+        const QBluetoothAddress &address, const QBluetoothUuid &uuid, QIODevice::OpenMode openMode)
+{
+    Q_UNUSED(address);
+    Q_UNUSED(uuid);
+    Q_UNUSED(openMode);
+
+    Q_Q(QBluetoothSocket);
+
+    qWarning() << "Using non-functional QBluetoothSocketPrivateDummy";
+    errorString = QBluetoothSocket::tr("Socket type not supported");
+    q->setSocketError(QBluetoothSocket::UnsupportedProtocolError);
+}
+
+void QBluetoothSocketPrivateDummy::connectToService(
+        const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
+{
+    Q_UNUSED(address);
+    Q_UNUSED(port);
+    Q_UNUSED(openMode);
+
+    Q_Q(QBluetoothSocket);
+
+    qWarning() << "Using non-functional QBluetoothSocketPrivateDummy";
+    errorString = QBluetoothSocket::tr("Socket type not supported");
+    q->setSocketError(QBluetoothSocket::UnsupportedProtocolError);
+}
+
+void QBluetoothSocketPrivateDummy::abort()
+{
+}
+
+QString QBluetoothSocketPrivateDummy::localName() const
+{
+    return QString();
+}
+
+QBluetoothAddress QBluetoothSocketPrivateDummy::localAddress() const
+{
+    return QBluetoothAddress();
+}
+
+quint16 QBluetoothSocketPrivateDummy::localPort() const
+{
+    return 0;
+}
+
+QString QBluetoothSocketPrivateDummy::peerName() const
+{
+    return QString();
+}
+
+QBluetoothAddress QBluetoothSocketPrivateDummy::peerAddress() const
+{
+    return QBluetoothAddress();
+}
+
+quint16 QBluetoothSocketPrivateDummy::peerPort() const
+{
+    return 0;
+}
+
+qint64 QBluetoothSocketPrivateDummy::writeData(const char *data, qint64 maxSize)
+{
+    Q_UNUSED(data);
+    Q_UNUSED(maxSize);
+
+    Q_Q(QBluetoothSocket);
+
+    if (state != QBluetoothSocket::ConnectedState) {
+        errorString = QBluetoothSocket::tr("Cannot write while not connected");
+        q->setSocketError(QBluetoothSocket::OperationError);
+        return -1;
+    }
+    return -1;
+}
+
+qint64 QBluetoothSocketPrivateDummy::readData(char *data, qint64 maxSize)
+{
+    Q_UNUSED(data);
+    Q_UNUSED(maxSize);
+
+    Q_Q(QBluetoothSocket);
+
+    if (state != QBluetoothSocket::ConnectedState) {
+        errorString = QBluetoothSocket::tr("Cannot read while not connected");
+        q->setSocketError(QBluetoothSocket::OperationError);
+        return -1;
+    }
+
+    return -1;
+}
+
+void QBluetoothSocketPrivateDummy::close()
+{
+}
+
+bool QBluetoothSocketPrivateDummy::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
+                                           QBluetoothSocket::SocketState socketState, QBluetoothSocket::OpenMode openMode)
+{
+    Q_UNUSED(socketDescriptor);
+    Q_UNUSED(socketType)
+    Q_UNUSED(socketState);
+    Q_UNUSED(openMode);
+    return false;
+}
+
+qint64 QBluetoothSocketPrivateDummy::bytesAvailable() const
+{
+    return 0;
+}
+
+bool QBluetoothSocketPrivateDummy::canReadLine() const
+{
+    return false;
+}
+
+qint64 QBluetoothSocketPrivateDummy::bytesToWrite() const
+{
+    return 0;
+}
+
+QT_END_NAMESPACE
diff --git a/src/bluetooth/qbluetoothsocket_dummy_p.h b/src/bluetooth/qbluetoothsocket_dummy_p.h
new file mode 100644
index 00000000..23bed109
--- /dev/null
+++ b/src/bluetooth/qbluetoothsocket_dummy_p.h
@@ -0,0 +1,107 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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 QBLUETOOTHSOCKET_DUMMY_H
+#define QBLUETOOTHSOCKET_DUMMY_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 "qbluetoothsocket.h"
+#include "qbluetoothsocketbase_p.h"
+#include <QtGlobal>
+
+QT_BEGIN_NAMESPACE
+
+class QBluetoothSocketPrivateDummy final : public QBluetoothSocketBasePrivate
+{
+    Q_OBJECT
+    friend class QBluetoothServerPrivate;
+
+public:
+    QBluetoothSocketPrivateDummy();
+    ~QBluetoothSocketPrivateDummy() override;
+
+    void connectToServiceHelper(const QBluetoothAddress &address,
+                          quint16 port,
+                          QIODevice::OpenMode openMode) override;
+
+    void connectToService(const QBluetoothServiceInfo &service,
+                          QIODevice::OpenMode openMode) override;
+    void connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid,
+                          QIODevice::OpenMode openMode) override;
+    void connectToService(const QBluetoothAddress &address, quint16 port,
+                          QIODevice::OpenMode openMode) override;
+
+    bool ensureNativeSocket(QBluetoothServiceInfo::Protocol type) override;
+
+    QString localName() const override;
+    QBluetoothAddress localAddress() const override;
+    quint16 localPort() const override;
+
+    QString peerName() const override;
+    QBluetoothAddress peerAddress() const override;
+    quint16 peerPort() const override;
+
+    void abort() override;
+    void close() override;
+
+    qint64 writeData(const char *data, qint64 maxSize) override;
+    qint64 readData(char *data, qint64 maxSize) override;
+
+    bool setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
+                             QBluetoothSocket::SocketState socketState = QBluetoothSocket::ConnectedState,
+                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite) override;
+
+    qint64 bytesAvailable() const override;
+    bool canReadLine() const override;
+    qint64 bytesToWrite() const override;
+};
+
+QT_END_NAMESPACE // QBLUETOOTHSOCKET_DUMMY_H
+
+#endif
diff --git a/src/bluetooth/qbluetoothsocket_osx.mm b/src/bluetooth/qbluetoothsocket_osx.mm
index de7e2120..ea39bb39 100644
--- a/src/bluetooth/qbluetoothsocket_osx.mm
+++ b/src/bluetooth/qbluetoothsocket_osx.mm
@@ -41,9 +41,7 @@
 // The order is important (the first header contains
 // the base class for a private socket) - workaround for
 // dependencies problem.
-#include "qbluetoothsocket_p.h"
-#include "qbluetoothsocket_osx_p.h"
-//
+#include "qbluetoothsocketbase_p.h"
 #include "qbluetoothsocket_osx_p.h"
 #include "qbluetoothlocaldevice.h"
 #include "qbluetoothdeviceinfo.h"
@@ -60,14 +58,14 @@
 QT_BEGIN_NAMESPACE
 
 QBluetoothSocketPrivate::QBluetoothSocketPrivate()
-  : q_ptr(nullptr),
-    writeChunk(std::numeric_limits<UInt16>::max()),
+  : writeChunk(std::numeric_limits<UInt16>::max()),
     openMode(QIODevice::NotOpen), // That's what is set in public class' ctors.
     state(QBluetoothSocket::UnconnectedState),
     socketType(QBluetoothServiceInfo::UnknownProtocol),
     socketError(QBluetoothSocket::NoSocketError),
     isConnecting(false)
 {
+    q_ptr = nullptr;
 }
 
 QBluetoothSocketPrivate::~QBluetoothSocketPrivate()
@@ -351,6 +349,7 @@ void QBluetoothSocketPrivate::channelClosed()
     if (!isConnecting) {
         q_ptr->setSocketState(QBluetoothSocket::UnconnectedState);
         q_ptr->setOpenMode(QIODevice::NotOpen);
+        emit q_ptr->readChannelFinished();
         emit q_ptr->disconnected();
     } else {
         state = QBluetoothSocket::UnconnectedState;
@@ -638,6 +637,7 @@ void QBluetoothSocket::abort()
     d_ptr->abort();
 
     setSocketState(QBluetoothSocket::UnconnectedState);
+    emit readChannelFinished();
     emit disconnected();
 }
 
@@ -726,6 +726,7 @@ void QBluetoothSocket::close()
     d_ptr->close();
 
     setSocketState(UnconnectedState);
+    emit readChannelFinished();
     emit disconnected();
 }
 
diff --git a/src/bluetooth/qbluetoothsocket_osx_p.h b/src/bluetooth/qbluetoothsocket_osx_p.h
index ce376702..dcc684b8 100644
--- a/src/bluetooth/qbluetoothsocket_osx_p.h
+++ b/src/bluetooth/qbluetoothsocket_osx_p.h
@@ -79,10 +79,9 @@
 
 QT_BEGIN_NAMESPACE
 
-class QBluetoothServiceDiscoveryAgent;
 class QBluetoothAddress;
 
-class QBluetoothSocketPrivate : public QBluetoothSocketPrivateBase, public OSXBluetooth::ChannelDelegate
+class QBluetoothSocketPrivate : public QBluetoothSocketBasePrivate, public OSXBluetooth::ChannelDelegate
 {
     friend class QBluetoothSocket;
     friend class QBluetoothServer;
@@ -121,8 +120,6 @@ private:
     qint64 writeData(const char *data, qint64 maxSize);
     qint64 readData(char *data, qint64 maxSize);
 
-    QBluetoothSocket *q_ptr;
-
     QScopedPointer<QBluetoothServiceDiscoveryAgent> discoveryAgent;
 
     QPrivateLinearBuffer buffer;
diff --git a/src/bluetooth/qbluetoothsocket_winrt.cpp b/src/bluetooth/qbluetoothsocket_winrt.cpp
index ec511974..556d9fc5 100644
--- a/src/bluetooth/qbluetoothsocket_winrt.cpp
+++ b/src/bluetooth/qbluetoothsocket_winrt.cpp
@@ -37,8 +37,7 @@
 **
 ****************************************************************************/
 
-#include "qbluetoothsocket.h"
-#include "qbluetoothsocket_p.h"
+#include "qbluetoothsocket_winrt_p.h"
 
 #ifdef CLASSIC_APP_BUILD
 #define Q_OS_WINRT
@@ -48,6 +47,8 @@
 #include <private/qeventdispatcher_winrt_p.h>
 
 #include <QtBluetooth/QBluetoothLocalDevice>
+#include <QtBluetooth/qbluetoothdeviceinfo.h>
+#include <QtBluetooth/qbluetoothserviceinfo.h>
 #include <QtCore/qloggingcategory.h>
 
 #include <robuffer.h>
@@ -129,7 +130,12 @@ public:
 
     ~SocketWorker()
     {
+    }
+    void close()
+    {
+        m_shuttingDown = true;
         if (Q_UNLIKELY(m_initialReadOp)) {
+            onReadyRead(m_initialReadOp.Get(), Canceled);
             ComPtr<IAsyncInfo> info;
             HRESULT hr = m_initialReadOp.As(&info);
             Q_ASSERT_SUCCEEDED(hr);
@@ -139,9 +145,11 @@ public:
                 hr = info->Close();
                 Q_ASSERT_SUCCEEDED(hr);
             }
+            m_initialReadOp.Reset();
         }
 
         if (m_readOp) {
+            onReadyRead(m_readOp.Get(), Canceled);
             ComPtr<IAsyncInfo> info;
             HRESULT hr = m_readOp.As(&info);
             Q_ASSERT_SUCCEEDED(hr);
@@ -151,6 +159,7 @@ public:
                 hr = info->Close();
                 Q_ASSERT_SUCCEEDED(hr);
             }
+            m_readOp.Reset();
         }
     }
 
@@ -190,6 +199,9 @@ public:
 
     HRESULT onReadyRead(IAsyncBufferOperation *asyncInfo, AsyncStatus status)
     {
+        if (m_shuttingDown)
+            return S_OK;
+
         if (asyncInfo == m_initialReadOp.Get()) {
             m_initialReadOp.Reset();
         } else if (asyncInfo == m_readOp.Get()) {
@@ -299,6 +311,7 @@ public:
 private:
     ComPtr<IStreamSocket> m_socket;
     QVector<QByteArray> m_pendingData;
+    bool m_shuttingDown = false;
 
     // Protects pendingData/pendingDatagrams which are accessed from native callbacks
     QMutex m_mutex;
@@ -307,26 +320,22 @@ private:
     ComPtr<IAsyncOperationWithProgress<IBuffer *, UINT32>> m_readOp;
 };
 
-QBluetoothSocketPrivate::QBluetoothSocketPrivate()
-    : socket(-1),
-      socketType(QBluetoothServiceInfo::UnknownProtocol),
-      state(QBluetoothSocket::UnconnectedState),
-      socketError(QBluetoothSocket::NoSocketError),
-      secFlags(QBluetooth::NoSecurity),
-      m_worker(new SocketWorker())
+QBluetoothSocketPrivateWinRT::QBluetoothSocketPrivateWinRT()
+    : m_worker(new SocketWorker())
 {
+    secFlags = QBluetooth::NoSecurity;
     connect(m_worker, &SocketWorker::newDataReceived,
-            this, &QBluetoothSocketPrivate::handleNewData, Qt::QueuedConnection);
+            this, &QBluetoothSocketPrivateWinRT::handleNewData, Qt::QueuedConnection);
     connect(m_worker, &SocketWorker::socketErrorOccured,
-            this, &QBluetoothSocketPrivate::handleError, Qt::QueuedConnection);
+            this, &QBluetoothSocketPrivateWinRT::handleError, Qt::QueuedConnection);
 }
 
-QBluetoothSocketPrivate::~QBluetoothSocketPrivate()
+QBluetoothSocketPrivateWinRT::~QBluetoothSocketPrivateWinRT()
 {
     abort();
 }
 
-bool QBluetoothSocketPrivate::ensureNativeSocket(QBluetoothServiceInfo::Protocol type)
+bool QBluetoothSocketPrivateWinRT::ensureNativeSocket(QBluetoothServiceInfo::Protocol type)
 {
     if (socket != -1) {
         if (type == socketType)
@@ -350,7 +359,7 @@ bool QBluetoothSocketPrivate::ensureNativeSocket(QBluetoothServiceInfo::Protocol
     return true;
 }
 
-void QBluetoothSocketPrivate::connectToService(const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
+void QBluetoothSocketPrivateWinRT::connectToServiceHelper(const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
 {
     Q_Q(QBluetoothSocket);
     Q_UNUSED(openMode);
@@ -369,14 +378,14 @@ void QBluetoothSocketPrivate::connectToService(const QBluetoothAddress &address,
     Q_ASSERT_SUCCEEDED(hr);
     ComPtr<IHostName> remoteHost;
     hr = hostNameFactory->CreateHostName(hostNameRef.Get(), &remoteHost);
-    RETURN_VOID_IF_FAILED("QBluetoothSocketPrivate::connectToService: Could not create hostname.");
+    RETURN_VOID_IF_FAILED("QBluetoothSocketPrivateWinRT::connectToService: Could not create hostname.");
 
     const QString portString = QString::number(port);
     HStringReference portReference(reinterpret_cast<LPCWSTR>(portString.utf16()));
 
     hr = m_socketObject->ConnectAsync(remoteHost.Get(), portReference.Get(), &m_connectOp);
     if (hr == E_ACCESSDENIED) {
-        qErrnoWarning(hr, "QBluetoothSocketPrivate::connectToService: Unable to connect to bluetooth socket."
+        qErrnoWarning(hr, "QBluetoothSocketPrivateWinRT::connectToService: Unable to connect to bluetooth socket."
             "Please check your manifest capabilities.");
         q->setSocketState(QBluetoothSocket::UnconnectedState);
         return;
@@ -388,22 +397,120 @@ void QBluetoothSocketPrivate::connectToService(const QBluetoothAddress &address,
     QEventDispatcherWinRT::runOnXamlThread([this]() {
         HRESULT hr;
         hr = m_connectOp->put_Completed(Callback<IAsyncActionCompletedHandler>(
-                                         this, &QBluetoothSocketPrivate::handleConnectOpFinished).Get());
+                                         this, &QBluetoothSocketPrivateWinRT::handleConnectOpFinished).Get());
         RETURN_HR_IF_FAILED("connectToHostByName: Could not register \"connectOp\" callback");
         return S_OK;
     });
 }
 
-void QBluetoothSocketPrivate::abort()
+void QBluetoothSocketPrivateWinRT::connectToService(
+        const QBluetoothServiceInfo &service, QIODevice::OpenMode openMode)
+{
+    Q_Q(QBluetoothSocket);
+
+    if (q->state() != QBluetoothSocket::UnconnectedState
+            && q->state() != QBluetoothSocket::ServiceLookupState) {
+        qCWarning(QT_BT_WINRT) << "QBluetoothSocket::connectToService called on busy socket";
+        errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
+        q->setSocketError(QBluetoothSocket::OperationError);
+        return;
+    }
+
+    // we are checking the service protocol and not socketType()
+    // socketType will change in ensureNativeSocket()
+    if (service.socketProtocol() != QBluetoothServiceInfo::RfcommProtocol) {
+        errorString = QBluetoothSocket::tr("Socket type not supported");
+        q->setSocketError(QBluetoothSocket::UnsupportedProtocolError);
+        return;
+    }
+
+    if (service.protocolServiceMultiplexer() > 0) {
+        Q_ASSERT(service.socketProtocol() == QBluetoothServiceInfo::L2capProtocol);
+
+       if (!ensureNativeSocket(QBluetoothServiceInfo::L2capProtocol)) {
+           errorString = QBluetoothSocket::tr("Unknown socket error");
+           q->setSocketError(QBluetoothSocket::UnknownSocketError);
+           return;
+       }
+       connectToServiceHelper(service.device().address(), service.protocolServiceMultiplexer(), openMode);
+   } else if (service.serverChannel() > 0) {
+        Q_ASSERT(service.socketProtocol() == QBluetoothServiceInfo::RfcommProtocol);
+
+       if (!ensureNativeSocket(QBluetoothServiceInfo::RfcommProtocol)) {
+           errorString = QBluetoothSocket::tr("Unknown socket error");
+           q->setSocketError(QBluetoothSocket::UnknownSocketError);
+           return;
+       }
+       connectToServiceHelper(service.device().address(), service.serverChannel(), openMode);
+   } else {
+       // try doing service discovery to see if we can find the socket
+       if (service.serviceUuid().isNull()
+               && !service.serviceClassUuids().contains(QBluetoothUuid::SerialPort)) {
+           qCWarning(QT_BT_WINRT) << "No port, no PSM, and no UUID provided. Unable to connect";
+           return;
+       }
+       qCDebug(QT_BT_WINRT) << "Need a port/psm, doing discovery";
+       q->doDeviceDiscovery(service, openMode);
+   }
+}
+
+void QBluetoothSocketPrivateWinRT::connectToService(
+        const QBluetoothAddress &address, const QBluetoothUuid &uuid, QIODevice::OpenMode openMode)
+{
+    Q_Q(QBluetoothSocket);
+
+    if (q->state() != QBluetoothSocket::UnconnectedState) {
+        qCWarning(QT_BT_WINRT) << "QBluetoothSocketPrivateWinRT::connectToService called on busy socket";
+        errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
+        q->setSocketError(QBluetoothSocket::OperationError);
+        return;
+    }
+
+    if (q->socketType() != QBluetoothServiceInfo::RfcommProtocol) {
+        errorString = QBluetoothSocket::tr("Socket type not supported");
+        q->setSocketError(QBluetoothSocket::UnsupportedProtocolError);
+        return;
+    }
+
+    QBluetoothServiceInfo service;
+    QBluetoothDeviceInfo device(address, QString(), QBluetoothDeviceInfo::MiscellaneousDevice);
+    service.setDevice(device);
+    service.setServiceUuid(uuid);
+    q->doDeviceDiscovery(service, openMode);
+}
+
+void QBluetoothSocketPrivateWinRT::connectToService(
+        const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode)
+{
+    Q_Q(QBluetoothSocket);
+
+    if (q->state() != QBluetoothSocket::UnconnectedState) {
+        qCWarning(QT_BT_WINRT) << "QBluetoothSocketPrivateWinRT::connectToService called on busy socket";
+        errorString = QBluetoothSocket::tr("Trying to connect while connection is in progress");
+        q->setSocketError(QBluetoothSocket::OperationError);
+        return;
+    }
+
+    if (q->socketType() != QBluetoothServiceInfo::RfcommProtocol) {
+        errorString = QBluetoothSocket::tr("Socket type not supported");
+        q->setSocketError(QBluetoothSocket::UnsupportedProtocolError);
+        return;
+    }
+
+     connectToServiceHelper(address, port, openMode);
+}
+
+void QBluetoothSocketPrivateWinRT::abort()
 {
     Q_Q(QBluetoothSocket);
     if (state == QBluetoothSocket::UnconnectedState)
         return;
 
     disconnect(m_worker, &SocketWorker::newDataReceived,
-        this, &QBluetoothSocketPrivate::handleNewData);
+        this, &QBluetoothSocketPrivateWinRT::handleNewData);
     disconnect(m_worker, &SocketWorker::socketErrorOccured,
-        this, &QBluetoothSocketPrivate::handleError);
+        this, &QBluetoothSocketPrivateWinRT::handleError);
+    m_worker->close();
     m_worker->deleteLater();
 
     if (socket != -1) {
@@ -413,7 +520,7 @@ void QBluetoothSocketPrivate::abort()
     q->setSocketState(QBluetoothSocket::UnconnectedState);
 }
 
-QString QBluetoothSocketPrivate::localName() const
+QString QBluetoothSocketPrivateWinRT::localName() const
 {
     const QBluetoothAddress address = localAddress();
     if (address.isNull())
@@ -423,7 +530,7 @@ QString QBluetoothSocketPrivate::localName() const
     return device.name();
 }
 
-QBluetoothAddress QBluetoothSocketPrivate::localAddress() const
+QBluetoothAddress QBluetoothSocketPrivateWinRT::localAddress() const
 {
     if (!m_socketObject)
         return QBluetoothAddress();
@@ -441,7 +548,7 @@ QBluetoothAddress QBluetoothSocketPrivate::localAddress() const
     return QBluetoothAddress(qt_QStringFromHString(localAddress));
 }
 
-quint16 QBluetoothSocketPrivate::localPort() const
+quint16 QBluetoothSocketPrivateWinRT::localPort() const
 {
     if (!m_socketObject)
         return 0;
@@ -456,7 +563,7 @@ quint16 QBluetoothSocketPrivate::localPort() const
     return qt_QStringFromHString(localPortString).toInt();
 }
 
-QString QBluetoothSocketPrivate::peerName() const
+QString QBluetoothSocketPrivateWinRT::peerName() const
 {
     if (!m_socketObject)
         return QString();
@@ -474,7 +581,7 @@ QString QBluetoothSocketPrivate::peerName() const
     return qt_QStringFromHString(remoteHostName);
 }
 
-QBluetoothAddress QBluetoothSocketPrivate::peerAddress() const
+QBluetoothAddress QBluetoothSocketPrivateWinRT::peerAddress() const
 {
     if (!m_socketObject)
         return QBluetoothAddress();
@@ -492,7 +599,7 @@ QBluetoothAddress QBluetoothSocketPrivate::peerAddress() const
     return QBluetoothAddress(qt_QStringFromHString(remoteAddress));
 }
 
-quint16 QBluetoothSocketPrivate::peerPort() const
+quint16 QBluetoothSocketPrivateWinRT::peerPort() const
 {
     if (!m_socketObject)
         return 0;
@@ -507,7 +614,7 @@ quint16 QBluetoothSocketPrivate::peerPort() const
     return qt_QStringFromHString(remotePortString).toInt();
 }
 
-qint64 QBluetoothSocketPrivate::writeData(const char *data, qint64 maxSize)
+qint64 QBluetoothSocketPrivateWinRT::writeData(const char *data, qint64 maxSize)
 {
     Q_Q(QBluetoothSocket);
 
@@ -533,7 +640,7 @@ qint64 QBluetoothSocketPrivate::writeData(const char *data, qint64 maxSize)
     return bytesWritten;
 }
 
-qint64 QBluetoothSocketPrivate::readData(char *data, qint64 maxSize)
+qint64 QBluetoothSocketPrivateWinRT::readData(char *data, qint64 maxSize)
 {
     Q_Q(QBluetoothSocket);
 
@@ -549,12 +656,12 @@ qint64 QBluetoothSocketPrivate::readData(char *data, qint64 maxSize)
     return 0;
 }
 
-void QBluetoothSocketPrivate::close()
+void QBluetoothSocketPrivateWinRT::close()
 {
     abort();
 }
 
-bool QBluetoothSocketPrivate::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
+bool QBluetoothSocketPrivateWinRT::setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
                                            QBluetoothSocket::SocketState socketState, QBluetoothSocket::OpenMode openMode)
 {
     Q_UNUSED(socketDescriptor);
@@ -565,7 +672,7 @@ bool QBluetoothSocketPrivate::setSocketDescriptor(int socketDescriptor, QBluetoo
     return false;
 }
 
-bool QBluetoothSocketPrivate::setSocketDescriptor(ComPtr<IStreamSocket> socketPtr, QBluetoothServiceInfo::Protocol socketType,
+bool QBluetoothSocketPrivateWinRT::setSocketDescriptor(ComPtr<IStreamSocket> socketPtr, QBluetoothServiceInfo::Protocol socketType,
                                            QBluetoothSocket::SocketState socketState, QBluetoothSocket::OpenMode openMode)
 {
     Q_Q(QBluetoothSocket);
@@ -582,22 +689,22 @@ bool QBluetoothSocketPrivate::setSocketDescriptor(ComPtr<IStreamSocket> socketPt
     return true;
 }
 
-qint64 QBluetoothSocketPrivate::bytesAvailable() const
+qint64 QBluetoothSocketPrivateWinRT::bytesAvailable() const
 {
     return buffer.size();
 }
 
-qint64 QBluetoothSocketPrivate::bytesToWrite() const
+qint64 QBluetoothSocketPrivateWinRT::bytesToWrite() const
 {
     return 0; // nothing because always unbuffered
 }
 
-bool QBluetoothSocketPrivate::canReadLine() const
+bool QBluetoothSocketPrivateWinRT::canReadLine() const
 {
     return buffer.canReadLine();
 }
 
-void QBluetoothSocketPrivate::handleNewData(const QVector<QByteArray> &data)
+void QBluetoothSocketPrivateWinRT::handleNewData(const QVector<QByteArray> &data)
 {
     // Defer putting the data into the list until the next event loop iteration
     // (where the readyRead signal is emitted as well)
@@ -605,7 +712,7 @@ void QBluetoothSocketPrivate::handleNewData(const QVector<QByteArray> &data)
                               Q_ARG(QVector<QByteArray>, data));
 }
 
-void QBluetoothSocketPrivate::handleError(QBluetoothSocket::SocketError error)
+void QBluetoothSocketPrivateWinRT::handleError(QBluetoothSocket::SocketError error)
 {
     Q_Q(QBluetoothSocket);
     switch (error) {
@@ -623,7 +730,7 @@ void QBluetoothSocketPrivate::handleError(QBluetoothSocket::SocketError error)
     q->setSocketState(QBluetoothSocket::UnconnectedState);
 }
 
-void QBluetoothSocketPrivate::addToPendingData(const QVector<QByteArray> &data)
+void QBluetoothSocketPrivateWinRT::addToPendingData(const QVector<QByteArray> &data)
 {
     Q_Q(QBluetoothSocket);
     QMutexLocker locker(&m_readMutex);
@@ -636,7 +743,7 @@ void QBluetoothSocketPrivate::addToPendingData(const QVector<QByteArray> &data)
     emit q->readyRead();
 }
 
-HRESULT QBluetoothSocketPrivate::handleConnectOpFinished(ABI::Windows::Foundation::IAsyncAction *action, ABI::Windows::Foundation::AsyncStatus status)
+HRESULT QBluetoothSocketPrivateWinRT::handleConnectOpFinished(ABI::Windows::Foundation::IAsyncAction *action, ABI::Windows::Foundation::AsyncStatus status)
 {
     Q_Q(QBluetoothSocket);
     if (status != Completed || !m_connectOp) { // Protect against a late callback
diff --git a/src/bluetooth/qbluetoothsocket_winrt_p.h b/src/bluetooth/qbluetoothsocket_winrt_p.h
new file mode 100644
index 00000000..6a740206
--- /dev/null
+++ b/src/bluetooth/qbluetoothsocket_winrt_p.h
@@ -0,0 +1,134 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 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 QBLUETOOTHSOCKET_WINRT_P_H
+#define QBLUETOOTHSOCKET_WINRT_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 "qbluetoothsocket.h"
+#include "qbluetoothsocketbase_p.h"
+#include <QtGlobal>
+
+QT_FORWARD_DECLARE_CLASS(SocketWorker)
+
+QT_BEGIN_NAMESPACE
+
+class QBluetoothSocketPrivateWinRT final: public QBluetoothSocketBasePrivate
+{
+    Q_OBJECT
+    friend class QBluetoothServerPrivate;
+
+public:
+    QBluetoothSocketPrivateWinRT();
+    ~QBluetoothSocketPrivateWinRT() override;
+
+    void connectToServiceHelper(const QBluetoothAddress &address,
+                          quint16 port,
+                          QIODevice::OpenMode openMode) override;
+
+    void connectToService(const QBluetoothServiceInfo &service,
+                          QIODevice::OpenMode openMode) override;
+    void connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid,
+                          QIODevice::OpenMode openMode) override;
+    void connectToService(const QBluetoothAddress &address, quint16 port,
+                          QIODevice::OpenMode openMode) override;
+
+    bool ensureNativeSocket(QBluetoothServiceInfo::Protocol type) override;
+
+    QString localName() const override;
+    QBluetoothAddress localAddress() const override;
+    quint16 localPort() const override;
+
+    QString peerName() const override;
+    QBluetoothAddress peerAddress() const override;
+    quint16 peerPort() const override;
+
+    void abort() override;
+    void close() override;
+
+    qint64 writeData(const char *data, qint64 maxSize) override;
+    qint64 readData(char *data, qint64 maxSize) override;
+
+    bool setSocketDescriptor(Microsoft::WRL::ComPtr<ABI::Windows::Networking::Sockets::IStreamSocket> socket,
+                             QBluetoothServiceInfo::Protocol socketType,
+                             QBluetoothSocket::SocketState socketState = QBluetoothSocket::ConnectedState,
+                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite) override;
+
+    bool setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
+                             QBluetoothSocket::SocketState socketState = QBluetoothSocket::ConnectedState,
+                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite) override;
+
+    qint64 bytesAvailable() const override;
+    bool canReadLine() const override;
+    qint64 bytesToWrite() const override;
+
+    SocketWorker *m_worker;
+
+    Microsoft::WRL::ComPtr<ABI::Windows::Networking::Sockets::IStreamSocket> m_socketObject;
+    Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncAction> m_connectOp;
+
+    QMutex m_readMutex;
+
+    // Protected by m_readMutex. Written in addToPendingData (native callback)
+    QVector<QByteArray> m_pendingData;
+
+    Q_INVOKABLE void addToPendingData(const QVector<QByteArray> &data);
+
+private slots:
+    void handleNewData(const QVector<QByteArray> &data);
+    void handleError(QBluetoothSocket::SocketError error);
+
+private:
+    HRESULT handleConnectOpFinished(ABI::Windows::Foundation::IAsyncAction *action,
+                                    ABI::Windows::Foundation::AsyncStatus status);
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/bluetooth/qbluetoothsocketbase.cpp b/src/bluetooth/qbluetoothsocketbase.cpp
new file mode 100644
index 00000000..8401a1c3
--- /dev/null
+++ b/src/bluetooth/qbluetoothsocketbase.cpp
@@ -0,0 +1,54 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 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 "qbluetoothsocketbase_p.h"
+
+QT_BEGIN_NAMESPACE
+
+QBluetoothSocketBasePrivate::QBluetoothSocketBasePrivate(QObject *parent) : QObject(parent)
+{
+
+}
+
+QBluetoothSocketBasePrivate::~QBluetoothSocketBasePrivate()
+{
+
+}
+
+QT_END_NAMESPACE
diff --git a/src/bluetooth/qbluetoothsocket_p.h b/src/bluetooth/qbluetoothsocketbase_p.h
index ae3c6182..410dcbbd 100644
--- a/src/bluetooth/qbluetoothsocket_p.h
+++ b/src/bluetooth/qbluetoothsocketbase_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2018 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtBluetooth module of the Qt Toolkit.
@@ -37,8 +37,8 @@
 **
 ****************************************************************************/
 
-#ifndef QBLUETOOTHSOCKET_P_H
-#define QBLUETOOTHSOCKET_P_H
+#ifndef QBLUETOOTHSOCKETBASEPRIVATE_P_H
+#define QBLUETOOTHSOCKETBASEPRIVATE_P_H
 
 //
 //  W A R N I N G
@@ -51,17 +51,15 @@
 // We mean it.
 //
 
-#include "qbluetoothsocket.h"
+#include <qglobal.h>
+#include <QObject>
+#include <QtBluetooth/qbluetoothsocket.h>
 
-#ifdef QT_ANDROID_BLUETOOTH
+#if defined(QT_ANDROID_BLUETOOTH)
 #include <QtAndroidExtras/QAndroidJniObject>
-#include <QtCore/QPointer>
-#include "android/inputstreamthread_p.h"
-#include <jni.h>
-class WorkerThread;
 #endif
 
-#ifdef QT_WINRT_BLUETOOTH
+#if defined(QT_WINRT_BLUETOOTH)
 #include <QtCore/QMutex>
 
 #include <wrl.h>
@@ -86,191 +84,97 @@ namespace ABI {
 #endif
 #include "qprivatelinearbuffer_p.h"
 
-#include <QtGlobal>
-
 QT_FORWARD_DECLARE_CLASS(QSocketNotifier)
+QT_FORWARD_DECLARE_CLASS(QBluetoothServiceDiscoveryAgent)
 
 QT_BEGIN_NAMESPACE
 
-#ifdef QT_WINRT_BLUETOOTH
-class SocketWorker;
-#endif
-
-class QBluetoothServiceDiscoveryAgent;
-
-class QSocketServerPrivate
-{
-public:
-    QSocketServerPrivate();
-    ~QSocketServerPrivate();
-};
-
-
-
-class QBluetoothSocket;
-class QBluetoothServiceDiscoveryAgent;
-
 #ifndef QT_OSX_BLUETOOTH
-class QBluetoothSocketPrivate : public QObject
+class QBluetoothSocketBasePrivate : public QObject
 {
     Q_OBJECT
-    Q_DECLARE_PUBLIC(QBluetoothSocket)
-    friend class QBluetoothServerPrivate;
 
 public:
+    explicit QBluetoothSocketBasePrivate(QObject *parent = nullptr);
+    virtual ~QBluetoothSocketBasePrivate();
 
-    QBluetoothSocketPrivate();
-    ~QBluetoothSocketPrivate();
+    virtual bool ensureNativeSocket(QBluetoothServiceInfo::Protocol type) = 0;
 
-//On Android we connect using the uuid not the port
-#if defined(QT_ANDROID_BLUETOOTH)
-    void connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid,
-                          QIODevice::OpenMode openMode);
-#else
-    void connectToService(const QBluetoothAddress &address, quint16 port, QIODevice::OpenMode openMode);
-#endif
-#ifdef QT_ANDROID_BLUETOOTH
-    bool fallBackConnect(QAndroidJniObject uuid, int channel);
-    bool fallBackReversedConnect(const QBluetoothUuid &uuid);
-#endif
+    virtual QString localName() const = 0;
+    virtual QBluetoothAddress localAddress() const = 0;
+    virtual quint16 localPort() const = 0;
 
+    virtual QString peerName() const = 0;
+    virtual QBluetoothAddress peerAddress() const = 0;
+    virtual quint16 peerPort() const = 0;
 
-    bool ensureNativeSocket(QBluetoothServiceInfo::Protocol type);
+    virtual void abort() = 0;
+    virtual void close() = 0;
 
-    QString localName() const;
-    QBluetoothAddress localAddress() const;
-    quint16 localPort() const;
+    virtual qint64 writeData(const char *data, qint64 maxSize) = 0;
+    virtual qint64 readData(char *data, qint64 maxSize) = 0;
 
-    QString peerName() const;
-    QBluetoothAddress peerAddress() const;
-    quint16 peerPort() const;
-    //QBluetoothServiceInfo peerService() const;
+    virtual qint64 bytesAvailable() const = 0;
+    virtual bool canReadLine() const = 0;
+    virtual qint64 bytesToWrite() const = 0;
 
-    void abort();
-    void close();
+    virtual bool setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
+                             QBluetoothSocket::SocketState socketState = QBluetoothSocket::ConnectedState,
+                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite) = 0;
 
-    //qint64 readBufferSize() const;
-    //void setReadBufferSize(qint64 size);
 
-    qint64 writeData(const char *data, qint64 maxSize);
-    qint64 readData(char *data, qint64 maxSize);
+#if defined(QT_ANDROID_BLUETOOTH)
+    virtual void connectToServiceHelper(const QBluetoothAddress &address, const QBluetoothUuid &uuid,
+                          QIODevice::OpenMode openMode) = 0;
+#else
+    virtual void connectToServiceHelper(const QBluetoothAddress &address, quint16 port,
+                                  QIODevice::OpenMode openMode) = 0;
+#endif
+    virtual void connectToService(const QBluetoothServiceInfo &service,
+                                  QIODevice::OpenMode openMode) = 0;
+    virtual void connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid,
+                                  QIODevice::OpenMode openMode) = 0;
+    virtual void connectToService(const QBluetoothAddress &address, quint16 port,
+                                  QIODevice::OpenMode openMode) = 0;
 
 #ifdef QT_ANDROID_BLUETOOTH
-    bool setSocketDescriptor(const QAndroidJniObject &socket, QBluetoothServiceInfo::Protocol socketType,
+    virtual bool setSocketDescriptor(const QAndroidJniObject &socket, QBluetoothServiceInfo::Protocol socketType,
                              QBluetoothSocket::SocketState socketState = QBluetoothSocket::ConnectedState,
-                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite);
+                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite) = 0;
 #elif defined(QT_WINRT_BLUETOOTH)
-    bool setSocketDescriptor(Microsoft::WRL::ComPtr<ABI::Windows::Networking::Sockets::IStreamSocket> socket,
+    virtual bool setSocketDescriptor(Microsoft::WRL::ComPtr<ABI::Windows::Networking::Sockets::IStreamSocket> socket,
                              QBluetoothServiceInfo::Protocol socketType,
                              QBluetoothSocket::SocketState socketState = QBluetoothSocket::ConnectedState,
-                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite);
+                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite) = 0;
 #endif
-    bool setSocketDescriptor(int socketDescriptor, QBluetoothServiceInfo::Protocol socketType,
-                             QBluetoothSocket::SocketState socketState = QBluetoothSocket::ConnectedState,
-                             QBluetoothSocket::OpenMode openMode = QBluetoothSocket::ReadWrite);
-
-    qint64 bytesAvailable() const;
-    bool canReadLine() const;
-    qint64 bytesToWrite() const;
 
 public:
     QPrivateLinearBuffer buffer;
     QPrivateLinearBuffer txBuffer;
-    int socket;
-    QBluetoothServiceInfo::Protocol socketType;
-    QBluetoothSocket::SocketState state;
-    QBluetoothSocket::SocketError socketError;
-    QSocketNotifier *readNotifier;
-    QSocketNotifier *connectWriteNotifier;
-    bool connecting;
-
-    QBluetoothServiceDiscoveryAgent *discoveryAgent;
+    int socket = -1;
+    QBluetoothServiceInfo::Protocol socketType = QBluetoothServiceInfo::UnknownProtocol;
+    QBluetoothSocket::SocketState state = QBluetoothSocket::UnconnectedState;
+    QBluetoothSocket::SocketError socketError = QBluetoothSocket::NoSocketError;
+    QSocketNotifier *readNotifier = nullptr;
+    QSocketNotifier *connectWriteNotifier = nullptr;
+    bool connecting = false;
+
+    QBluetoothServiceDiscoveryAgent *discoveryAgent = nullptr;
     QBluetoothSocket::OpenMode openMode;
     QBluetooth::SecurityFlags secFlags;
 
-
-//    QByteArray rxBuffer;
-//    qint64 rxOffset;
     QString errorString;
 
-#ifdef QT_ANDROID_BLUETOOTH
-    QAndroidJniObject adapter;
-    QAndroidJniObject socketObject;
-    QAndroidJniObject remoteDevice;
-    QAndroidJniObject inputStream;
-    QAndroidJniObject outputStream;
-    InputStreamThread *inputThread;
-
-public slots:
-    void socketConnectSuccess(const QAndroidJniObject &socket);
-    void defaultSocketConnectFailed(const QAndroidJniObject & socket,
-                                    const QAndroidJniObject &targetUuid,
-                                    const QBluetoothUuid &qtTargetUuid);
-    void fallbackSocketConnectFailed(const QAndroidJniObject &socket,
-                                     const QAndroidJniObject &targetUuid);
-    void inputThreadError(int errorCode);
-
-signals:
-    void connectJavaSocket();
-    void closeJavaSocket();
-
-#endif
-
-#ifdef QT_WINRT_BLUETOOTH
-    SocketWorker *m_worker;
-
-    Microsoft::WRL::ComPtr<ABI::Windows::Networking::Sockets::IStreamSocket> m_socketObject;
-    Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncAction> m_connectOp;
-
-    QMutex m_readMutex;
-
-    // Protected by m_readMutex. Written in addToPendingData (native callback)
-    QVector<QByteArray> m_pendingData;
-
-    Q_INVOKABLE void addToPendingData(const QVector<QByteArray> &data);
-
-private slots:
-    void handleNewData(const QVector<QByteArray> &data);
-    void handleError(QBluetoothSocket::SocketError error);
-#endif // QT_WINRT_BLUETOOTH
-
-#if QT_CONFIG(bluez)
-private slots:
-    void _q_readNotify();
-    void _q_writeNotify();
-#endif
-
 protected:
+    Q_DECLARE_PUBLIC(QBluetoothSocket)
     QBluetoothSocket *q_ptr;
 
-private:
-
-#ifdef QT_WINRT_BLUETOOTH
-    HRESULT handleConnectOpFinished(ABI::Windows::Foundation::IAsyncAction *action, ABI::Windows::Foundation::AsyncStatus status);
-#endif
-
 #if QT_CONFIG(bluez)
 public:
-    quint8 lowEnergySocketType;
+    quint8 lowEnergySocketType = 0;
 #endif
 };
 
-#else // QT_OSX_BLUETOOTH
-
-// QBluetoothSocketPrivate on OS X can not contain
-// Q_OBJECT (moc does not parse Objective-C syntax).
-// But QBluetoothSocket still requires QMetaObject::invokeMethod
-// to work. Here's the trick:
-class QBluetoothSocketPrivateBase : public QObject
-{
-// The most important part of it:
-    Q_OBJECT
-public slots:
-    virtual void _q_writeNotify() = 0;
-};
-
-#endif // QT_OSX_BLUETOOTH
-
 static inline void convertAddress(const quint64 from, quint8 (&to)[6])
 {
     to[0] = (from >> 0) & 0xff;
@@ -281,7 +185,7 @@ static inline void convertAddress(const quint64 from, quint8 (&to)[6])
     to[5] = (from >> 40) & 0xff;
 }
 
-static inline quint64 convertAddress(const quint8 (&from)[6], quint64 *to = 0)
+static inline quint64 convertAddress(const quint8 (&from)[6], quint64 *to = nullptr)
 {
     const quint64 result = (quint64(from[0]) << 0) |
          (quint64(from[1]) << 8) |
@@ -294,16 +198,26 @@ static inline quint64 convertAddress(const quint8 (&from)[6], quint64 *to = 0)
     return result;
 }
 
-#ifdef Q_OS_ANDROID
-// QTBUG-61392 related
-// Private API to disable the silent behavior to reverse a remote service's
-// UUID. In rare cases the workaround behavior might not be desirable as
-// it may lead to connects to incorrect services.
-extern bool useReverseUuidWorkAroundConnect;
+#else // QT_OSX_BLUETOOTH
 
-#endif
+// QBluetoothSocketPrivate on macOS can not contain
+// Q_OBJECT (moc does not parse Objective-C syntax).
+// But QBluetoothSocket still requires QMetaObject::invokeMethod
+// to work. Here's the trick:
+class QBluetoothSocketBasePrivate : public QObject
+{
+// The most important part of it:
+    Q_OBJECT
+public slots:
+    virtual void _q_writeNotify() = 0;
 
-QT_END_NAMESPACE
+protected:
+    Q_DECLARE_PUBLIC(QBluetoothSocket)
+    QBluetoothSocket *q_ptr;
+};
 
+#endif // QT_OSX_BLUETOOTH
 
-#endif
+QT_END_NAMESPACE
+
+#endif // QBLUETOOTHSOCKETBASE_P_H
diff --git a/src/bluetooth/qleadvertiser_bluez.cpp b/src/bluetooth/qleadvertiser_bluez.cpp
index b964f620..bff5a590 100644
--- a/src/bluetooth/qleadvertiser_bluez.cpp
+++ b/src/bluetooth/qleadvertiser_bluez.cpp
@@ -41,7 +41,7 @@
 
 #include "bluez/bluez_data_p.h"
 #include "bluez/hcimanager_p.h"
-#include "qbluetoothsocket_p.h"
+#include "qbluetoothsocketbase_p.h"
 
 #include <QtCore/qloggingcategory.h>
 
diff --git a/src/bluetooth/qlowenergycontroller.cpp b/src/bluetooth/qlowenergycontroller.cpp
index b9b7080c..14efe764 100644
--- a/src/bluetooth/qlowenergycontroller.cpp
+++ b/src/bluetooth/qlowenergycontroller.cpp
@@ -294,11 +294,13 @@ void registerQLowEnergyControllerMetaType()
     }
 }
 
-static QLowEnergyControllerPrivate *privateController()
+static QLowEnergyControllerPrivate *privateController(QLowEnergyController::Role role)
 {
 #if QT_CONFIG(bluez) && !defined(QT_BLUEZ_NO_BTLE)
-    // for now Bluez DBus disabled
-    if (false && bluetoothdVersion() >= QVersionNumber(5, 42)) {
+    // The new DBUS implementation only supports Central role for now
+    // For Peripheral role support see QTBUG-66909
+    if (role == QLowEnergyController::CentralRole
+            && bluetoothdVersion() >= QVersionNumber(5, 42)) {
         qCWarning(QT_BT) << "Using BlueZ LE DBus API";
         return new QLowEnergyControllerPrivateBluezDBus();
     } else {
@@ -306,12 +308,15 @@ static QLowEnergyControllerPrivate *privateController()
         return new QLowEnergyControllerPrivateBluez();
     }
 #elif defined(QT_ANDROID_BLUETOOTH)
+    Q_UNUSED(role);
     return new QLowEnergyControllerPrivateAndroid();
 #elif defined(QT_WINRT_BLUETOOTH)
+    Q_UNUSED(role);
     return new QLowEnergyControllerPrivateWinRT();
 #elif defined(QT_WIN_BLUETOOTH)
     return new QLowEnergyControllerPrivateWin32();
 #else
+    Q_UNUSED(role);
     return new QLowEnergyControllerPrivateCommon();
 #endif
 }
@@ -333,7 +338,7 @@ QLowEnergyController::QLowEnergyController(
                             QObject *parent)
     : QObject(parent)
 {
-    d_ptr = privateController();
+    d_ptr = privateController(CentralRole);
 
     Q_D(QLowEnergyController);
     d->q_ptr = this;
@@ -362,7 +367,7 @@ QLowEnergyController::QLowEnergyController(
                             QObject *parent)
     : QObject(parent)
 {
-        d_ptr = privateController();
+        d_ptr = privateController(CentralRole);
 
     Q_D(QLowEnergyController);
     d->q_ptr = this;
@@ -395,7 +400,7 @@ QLowEnergyController::QLowEnergyController(
                             QObject *parent)
     : QObject(parent)
 {
-    d_ptr = privateController();
+    d_ptr = privateController(CentralRole);
 
     Q_D(QLowEnergyController);
     d->q_ptr = this;
@@ -440,7 +445,7 @@ QLowEnergyController *QLowEnergyController::createPeripheral(QObject *parent)
 QLowEnergyController::QLowEnergyController(QObject *parent)
     : QObject(parent)
 {
-    d_ptr = privateController();
+    d_ptr = privateController(PeripheralRole);
 
     Q_D(QLowEnergyController);
     d->q_ptr = this;
@@ -602,9 +607,10 @@ void QLowEnergyController::connectToDevice()
 
     This function does nothing if the controller is in the \l UnconnectedState.
 
-    If the controller is in the peripheral role, it stops advertising too.
-    The application must restart the advertising mode by calling
-    \l startAdvertising().
+    If the controller is in the peripheral role, it stops advertising and removes
+    all services which have previously been added via \l addService().
+    To reuse the QLowEnergyController instance the application must re-add services
+    and restart the advertising mode by calling \l startAdvertising().
 
     \sa connectToDevice()
  */
@@ -741,6 +747,9 @@ void QLowEnergyController::startAdvertising(const QLowEnergyAdvertisingParameter
 /*!
    Stops advertising, if this object is currently in the advertising state.
 
+   The controller has to be in the \l PeripheralRole for this function to work.
+   It does not invalidate services which have previously been added via \l addService().
+
    \since 5.7
    \sa startAdvertising()
  */
@@ -759,8 +768,15 @@ void QLowEnergyController::stopAdvertising()
   The controller must be in the \l PeripheralRole and in the \l UnconnectedState. The \a service
   object must be valid.
 
+  \note Once the peripheral instance is disconnected from the remote central device or
+  if \l disconnectFromDevice() is manually called, every service definition that was
+  previously added via this function is removed from the peripheral. Therefore this function
+  must be called again before re-advertising this peripheral controller instance. The described
+  behavior is connection specific and therefore not dependent on whether \l stopAdvertising()
+  was called.
+
   \since 5.7
-  \sa QLowEnergyServiceData::addIncludedService
+  \sa stopAdvertising(), disconnectFromDevice(), QLowEnergyServiceData::addIncludedService
  */
 QLowEnergyService *QLowEnergyController::addService(const QLowEnergyServiceData &service,
                                                     QObject *parent)
diff --git a/src/bluetooth/qlowenergycontroller_android.cpp b/src/bluetooth/qlowenergycontroller_android.cpp
index 8dccb859..54665f7b 100644
--- a/src/bluetooth/qlowenergycontroller_android.cpp
+++ b/src/bluetooth/qlowenergycontroller_android.cpp
@@ -40,6 +40,7 @@
 #include "qlowenergycontroller_android_p.h"
 #include <QtCore/QLoggingCategory>
 #include <QtAndroidExtras/QAndroidJniEnvironment>
+#include <QtAndroidExtras/QAndroidJniObject>
 #include <QtBluetooth/QLowEnergyServiceData>
 #include <QtBluetooth/QLowEnergyCharacteristicData>
 #include <QtBluetooth/QLowEnergyDescriptorData>
@@ -179,8 +180,12 @@ void QLowEnergyControllerPrivateAndroid::disconnectFromDevice()
     QLowEnergyController::ControllerState oldState = state;
     setState(QLowEnergyController::ClosingState);
 
-    if (hub)
-        hub->javaObject().callMethod<void>("disconnect");
+    if (hub) {
+        if (role == QLowEnergyController::PeripheralRole)
+            hub->javaObject().callMethod<void>("disconnectServer");
+        else
+            hub->javaObject().callMethod<void>("disconnect");
+    }
 
     if (oldState == QLowEnergyController::ConnectingState)
         setState(QLowEnergyController::UnconnectedState);
@@ -429,9 +434,15 @@ void QLowEnergyControllerPrivateAndroid::peripheralConnectionUpdated(
     Q_Q(QLowEnergyController);
     if (oldState == QLowEnergyController::ConnectedState
             && newState != QLowEnergyController::ConnectedState) {
+        remoteDevice.clear();
+        remoteName.clear();
         emit q->disconnected();
     } else if (newState == QLowEnergyController::ConnectedState
                  && oldState != QLowEnergyController::ConnectedState) {
+        if (hub) {
+            remoteDevice = QBluetoothAddress(hub->javaObject().callObjectMethod<jstring>("remoteAddress").toString());
+            remoteName = hub->javaObject().callObjectMethod<jstring>("remoteName").toString();
+        }
         emit q->connected();
     }
 }
diff --git a/src/bluetooth/qlowenergycontroller_android_p.h b/src/bluetooth/qlowenergycontroller_android_p.h
index e575d96e..3f97e363 100644
--- a/src/bluetooth/qlowenergycontroller_android_p.h
+++ b/src/bluetooth/qlowenergycontroller_android_p.h
@@ -92,12 +92,12 @@ extern void registerQLowEnergyControllerMetaType();
 
 class QLeAdvertiser;
 
-class QLowEnergyControllerPrivateAndroid : public QLowEnergyControllerPrivate
+class QLowEnergyControllerPrivateAndroid final : public QLowEnergyControllerPrivate
 {
     Q_OBJECT
 public:
     QLowEnergyControllerPrivateAndroid();
-    ~QLowEnergyControllerPrivateAndroid();
+    ~QLowEnergyControllerPrivateAndroid() override;
 
     void init() override;
 
diff --git a/src/bluetooth/qlowenergycontroller_bluez.cpp b/src/bluetooth/qlowenergycontroller_bluez.cpp
index c4ff0e7f..502f42ad 100644
--- a/src/bluetooth/qlowenergycontroller_bluez.cpp
+++ b/src/bluetooth/qlowenergycontroller_bluez.cpp
@@ -40,14 +40,20 @@
 
 #include "lecmaccalculator_p.h"
 #include "qlowenergycontroller_bluez_p.h"
-#include "qbluetoothsocket_p.h"
+#include "qbluetoothsocketbase_p.h"
 #include "qleadvertiser_p.h"
 #include "bluez/bluez_data_p.h"
 #include "bluez/hcimanager_p.h"
+#include "bluez/objectmanager_p.h"
 #include "bluez/remotedevicemanager_p.h"
 #include "bluez/bluez5_helper_p.h"
 #include "bluez/bluetoothmanagement_p.h"
 
+// Bluez 4
+#include "bluez/adapter_p.h"
+#include "bluez/device_p.h"
+#include "bluez/manager_p.h"
+
 #include <QtCore/QFileInfo>
 #include <QtCore/QLoggingCategory>
 #include <QtCore/QSettings>
@@ -746,8 +752,11 @@ void QLowEnergyControllerPrivateBluez::l2cpDisconnected()
 {
     Q_Q(QLowEnergyController);
 
-    if (role == QLowEnergyController::PeripheralRole)
+    if (role == QLowEnergyController::PeripheralRole) {
         storeClientConfigurations();
+        remoteDevice.clear();
+        remoteName.clear();
+    }
     invalidateServices();
     resetController();
     setState(QLowEnergyController::UnconnectedState);
@@ -796,12 +805,16 @@ void QLowEnergyControllerPrivateBluez::resetController()
     requestPending = false;
     encryptionChangePending = false;
     receivedMtuExchangeRequest = false;
+    mtuSize = ATT_DEFAULT_LE_MTU;
     securityLevelValue = -1;
     connectionHandle = 0;
 
-    // public API behavior requires stop of advertisement
-    if (role == QLowEnergyController::PeripheralRole && advertiser)
-        advertiser->stopAdvertising();
+    if (role == QLowEnergyController::PeripheralRole) {
+        // public API behavior requires stop of advertisement
+        if (advertiser)
+            advertiser->stopAdvertising();
+        localAttributes.clear();
+    }
 }
 
 void QLowEnergyControllerPrivateBluez::restartRequestTimer()
@@ -3011,6 +3024,69 @@ void QLowEnergyControllerPrivateBluez::sendNextIndication()
         sendIndication(scheduledIndications.takeFirst());
 }
 
+static QString nameOfRemoteCentral(const QBluetoothAddress &peerAddress, const QBluetoothAddress &localAdapter)
+{
+    const QString peerAddressString = peerAddress.toString();
+    if (isBluez5()) {
+        OrgFreedesktopDBusObjectManagerInterface manager(QStringLiteral("org.bluez"),
+                                                         QStringLiteral("/"),
+                                                         QDBusConnection::systemBus());
+        QDBusPendingReply<ManagedObjectList> reply = manager.GetManagedObjects();
+        reply.waitForFinished();
+        if (reply.isError())
+            return QString();
+
+        ManagedObjectList managedObjectList = reply.value();
+        for (ManagedObjectList::const_iterator it = managedObjectList.constBegin(); it != managedObjectList.constEnd(); ++it) {
+            const InterfaceList &ifaceList = it.value();
+
+            for (InterfaceList::const_iterator jt = ifaceList.constBegin(); jt != ifaceList.constEnd(); ++jt) {
+                const QString &iface = jt.key();
+                const QVariantMap &ifaceValues = jt.value();
+
+                if (iface == QStringLiteral("org.bluez.Device1")) {
+                    if (ifaceValues.value(QStringLiteral("Address")).toString() == peerAddressString)
+                        return ifaceValues.value(QStringLiteral("Alias")).toString();
+                }
+            }
+        }
+        return QString();
+    } else {
+        OrgBluezManagerInterface manager(QStringLiteral("org.bluez"), QStringLiteral("/"),
+                                         QDBusConnection::systemBus());
+
+        QDBusPendingReply<QDBusObjectPath> reply = manager.FindAdapter(localAdapter.toString());
+        reply.waitForFinished();
+        if (reply.isError())
+            return QString();
+
+        OrgBluezAdapterInterface adapter(QStringLiteral("org.bluez"), reply.value().path(),
+                                         QDBusConnection::systemBus());
+
+        QDBusPendingReply<QDBusObjectPath> deviceObjectPath = adapter.FindDevice(peerAddressString);
+        deviceObjectPath.waitForFinished();
+        if (deviceObjectPath.isError()) {
+            if (deviceObjectPath.error().name() != QStringLiteral("org.bluez.Error.DoesNotExist"))
+                return QString();
+
+            deviceObjectPath = adapter.CreateDevice(peerAddressString);
+            deviceObjectPath.waitForFinished();
+            if (deviceObjectPath.isError())
+                return QString();
+        }
+
+        OrgBluezDeviceInterface device(QStringLiteral("org.bluez"), deviceObjectPath.value().path(),
+                                       QDBusConnection::systemBus());
+
+        QDBusPendingReply<QVariantMap> properties = device.GetProperties();
+        properties.waitForFinished();
+        if (properties.isError())
+            return QString();
+
+        return properties.value().value(QStringLiteral("Alias")).toString();
+    }
+}
+
 void QLowEnergyControllerPrivateBluez::handleConnectionRequest()
 {
     if (state != QLowEnergyController::AdvertisingState) {
@@ -3029,8 +3105,11 @@ void QLowEnergyControllerPrivateBluez::handleConnectionRequest()
         serverSocketNotifier->setEnabled(true);
         return;
     }
+
     remoteDevice = QBluetoothAddress(convertAddress(clientAddr.l2_bdaddr.b));
-    qCDebug(QT_BT_BLUEZ) << "GATT connection from device" << remoteDevice;
+    remoteName = nameOfRemoteCentral(remoteDevice, localAdapter);
+    qCDebug(QT_BT_BLUEZ) << "GATT connection from device" << remoteDevice << remoteName;
+
     if (connectionHandle == 0)
         qCWarning(QT_BT_BLUEZ) << "Received client connection, but no connection complete event";
 
diff --git a/src/bluetooth/qlowenergycontroller_bluez_p.h b/src/bluetooth/qlowenergycontroller_bluez_p.h
index 55a8a482..66c048be 100644
--- a/src/bluetooth/qlowenergycontroller_bluez_p.h
+++ b/src/bluetooth/qlowenergycontroller_bluez_p.h
@@ -76,12 +76,12 @@ extern void registerQLowEnergyControllerMetaType();
 
 class QLeAdvertiser;
 
-class QLowEnergyControllerPrivateBluez : public QLowEnergyControllerPrivate
+class QLowEnergyControllerPrivateBluez final: public QLowEnergyControllerPrivate
 {
     Q_OBJECT
 public:
     QLowEnergyControllerPrivateBluez();
-    ~QLowEnergyControllerPrivateBluez();
+    ~QLowEnergyControllerPrivateBluez() override;
 
     void init() override;
 
diff --git a/src/bluetooth/qlowenergycontroller_bluezdbus.cpp b/src/bluetooth/qlowenergycontroller_bluezdbus.cpp
index e9087642..16f03405 100644
--- a/src/bluetooth/qlowenergycontroller_bluezdbus.cpp
+++ b/src/bluetooth/qlowenergycontroller_bluezdbus.cpp
@@ -289,7 +289,10 @@ void QLowEnergyControllerPrivateBluezDBus::connectToDevice()
     if (device->connected() && device->servicesResolved()) {
         //connectToDevice is noop
         disconnectSignalRequired = true;
+
         setState(QLowEnergyController::ConnectedState);
+        Q_Q(QLowEnergyController);
+        emit q->connected();
         return;
     }
 
@@ -537,8 +540,12 @@ void QLowEnergyControllerPrivateBluezDBus::discoverServiceDetails(const QBluetoo
     serviceData->endHandle = runningHandle++;
 
     // last job is last step of service discovery
-    GattJob &lastJob = jobs.last();
-    lastJob.flags.setFlag(GattJob::LastServiceDiscovery, true);
+    if (!jobs.isEmpty()) {
+        GattJob &lastJob = jobs.last();
+        lastJob.flags.setFlag(GattJob::LastServiceDiscovery, true);
+    } else {
+        serviceData->setState(QLowEnergyService::ServiceDiscovered);
+    }
 
     scheduleNextJob();
 }
@@ -553,8 +560,12 @@ void QLowEnergyControllerPrivateBluezDBus::prepareNextJob()
 
 void QLowEnergyControllerPrivateBluezDBus::onCharReadFinished(QDBusPendingCallWatcher *call)
 {
-    Q_ASSERT(jobPending);
-    Q_ASSERT(!jobs.isEmpty());
+    if (!jobPending || jobs.isEmpty()) {
+        // this may happen when service disconnects before dbus watcher returns later on
+        qCWarning(QT_BT_BLUEZ) << "Aborting onCharReadFinished due to disconnect";
+        Q_ASSERT(state == QLowEnergyController::UnconnectedState);
+        return;
+    }
 
     const GattJob nextJob = jobs.constFirst();
     Q_ASSERT(nextJob.flags.testFlag(GattJob::CharRead));
@@ -597,8 +608,12 @@ void QLowEnergyControllerPrivateBluezDBus::onCharReadFinished(QDBusPendingCallWa
 
 void QLowEnergyControllerPrivateBluezDBus::onDescReadFinished(QDBusPendingCallWatcher *call)
 {
-    Q_ASSERT(jobPending);
-    Q_ASSERT(!jobs.isEmpty());
+    if (!jobPending || jobs.isEmpty()) {
+        // this may happen when service disconnects before dbus watcher returns later on
+        qCWarning(QT_BT_BLUEZ) << "Aborting onDescReadFinished due to disconnect";
+        Q_ASSERT(state == QLowEnergyController::UnconnectedState);
+        return;
+    }
 
     const GattJob nextJob = jobs.constFirst();
     Q_ASSERT(nextJob.flags.testFlag(GattJob::DescRead));
@@ -659,8 +674,12 @@ void QLowEnergyControllerPrivateBluezDBus::onDescReadFinished(QDBusPendingCallWa
 
 void QLowEnergyControllerPrivateBluezDBus::onCharWriteFinished(QDBusPendingCallWatcher *call)
 {
-    Q_ASSERT(jobPending);
-    Q_ASSERT(!jobs.isEmpty());
+    if (!jobPending || jobs.isEmpty()) {
+        // this may happen when service disconnects before dbus watcher returns later on
+        qCWarning(QT_BT_BLUEZ) << "Aborting onCharWriteFinished due to disconnect";
+        Q_ASSERT(state == QLowEnergyController::UnconnectedState);
+        return;
+    }
 
     const GattJob nextJob = jobs.constFirst();
     Q_ASSERT(nextJob.flags.testFlag(GattJob::CharWrite));
@@ -700,8 +719,12 @@ void QLowEnergyControllerPrivateBluezDBus::onCharWriteFinished(QDBusPendingCallW
 
 void QLowEnergyControllerPrivateBluezDBus::onDescWriteFinished(QDBusPendingCallWatcher *call)
 {
-    Q_ASSERT(jobPending);
-    Q_ASSERT(!jobs.isEmpty());
+    if (!jobPending || jobs.isEmpty()) {
+        // this may happen when service disconnects before dbus watcher returns later on
+        qCWarning(QT_BT_BLUEZ) << "Aborting onDescWriteFinished due to disconnect";
+        Q_ASSERT(state == QLowEnergyController::UnconnectedState);
+        return;
+    }
 
     const GattJob nextJob = jobs.constFirst();
     Q_ASSERT(nextJob.flags.testFlag(GattJob::DescWrite));
diff --git a/src/bluetooth/qlowenergycontroller_bluezdbus_p.h b/src/bluetooth/qlowenergycontroller_bluezdbus_p.h
index 7ac1808f..0e0bfcb5 100644
--- a/src/bluetooth/qlowenergycontroller_bluezdbus_p.h
+++ b/src/bluetooth/qlowenergycontroller_bluezdbus_p.h
@@ -69,12 +69,12 @@ QT_BEGIN_NAMESPACE
 
 class QDBusPendingCallWatcher;
 
-class QLowEnergyControllerPrivateBluezDBus : public QLowEnergyControllerPrivate
+class QLowEnergyControllerPrivateBluezDBus final : public QLowEnergyControllerPrivate
 {
     Q_OBJECT
 public:
     QLowEnergyControllerPrivateBluezDBus();
-    ~QLowEnergyControllerPrivateBluezDBus();
+    ~QLowEnergyControllerPrivateBluezDBus() override;
 
     void init() override;
     void connectToDevice() override;
diff --git a/src/bluetooth/qlowenergycontroller_p.h b/src/bluetooth/qlowenergycontroller_p.h
index 301cd15e..fe1da852 100644
--- a/src/bluetooth/qlowenergycontroller_p.h
+++ b/src/bluetooth/qlowenergycontroller_p.h
@@ -65,12 +65,12 @@ class QLowEnergyServiceData;
 
 extern void registerQLowEnergyControllerMetaType();
 
-class QLowEnergyControllerPrivateCommon : public QLowEnergyControllerPrivate
+class QLowEnergyControllerPrivateCommon final : public QLowEnergyControllerPrivate
 {
     Q_OBJECT
 public:
     QLowEnergyControllerPrivateCommon();
-    ~QLowEnergyControllerPrivateCommon();
+    ~QLowEnergyControllerPrivateCommon() override;
 
     void init() override;
 
diff --git a/src/bluetooth/qlowenergycontroller_winrt.cpp b/src/bluetooth/qlowenergycontroller_winrt.cpp
index 628f1195..917f3790 100644
--- a/src/bluetooth/qlowenergycontroller_winrt.cpp
+++ b/src/bluetooth/qlowenergycontroller_winrt.cpp
@@ -937,7 +937,7 @@ void QLowEnergyControllerPrivateWinRT::writeCharacteristic(const QSharedPointer<
         GattWriteOption option = writeWithResponse ? GattWriteOption_WriteWithResponse : GattWriteOption_WriteWithoutResponse;
         hr = characteristic->WriteValueWithOptionAsync(buffer.Get(), option, &writeOp);
         Q_ASSERT_SUCCEEDED(hr);
-        auto writeCompletedLambda =[charData, charHandle, newValue, service, this]
+        auto writeCompletedLambda =[charData, charHandle, newValue, service, writeWithResponse, this]
                 (IAsyncOperation<GattCommunicationStatus> *op, AsyncStatus status)
         {
             if (status == AsyncStatus::Canceled || status == AsyncStatus::Error) {
@@ -963,7 +963,8 @@ void QLowEnergyControllerPrivateWinRT::writeCharacteristic(const QSharedPointer<
             // empty.
             if (charData.properties & QLowEnergyCharacteristic::Read)
                 updateValueOfCharacteristic(charHandle, newValue, false);
-            emit service->characteristicWritten(QLowEnergyCharacteristic(service, charHandle), newValue);
+            if (writeWithResponse)
+                emit service->characteristicWritten(QLowEnergyCharacteristic(service, charHandle), newValue);
             return S_OK;
         };
         hr = writeOp->put_Completed(Callback<IAsyncOperationCompletedHandler<GattCommunicationStatus>>(writeCompletedLambda).Get());
diff --git a/src/bluetooth/qlowenergycontroller_winrt_p.h b/src/bluetooth/qlowenergycontroller_winrt_p.h
index 7edc4702..783a71fa 100644
--- a/src/bluetooth/qlowenergycontroller_winrt_p.h
+++ b/src/bluetooth/qlowenergycontroller_winrt_p.h
@@ -73,12 +73,12 @@ class QWinRTLowEnergyServiceHandler;
 
 extern void registerQLowEnergyControllerMetaType();
 
-class QLowEnergyControllerPrivateWinRT : public QLowEnergyControllerPrivate
+class QLowEnergyControllerPrivateWinRT final : public QLowEnergyControllerPrivate
 {
     Q_OBJECT
 public:
     QLowEnergyControllerPrivateWinRT();
-    ~QLowEnergyControllerPrivateWinRT();
+    ~QLowEnergyControllerPrivateWinRT() override;
 
     void init() override;
 
diff --git a/src/bluetooth/qlowenergycontrollerbase.cpp b/src/bluetooth/qlowenergycontrollerbase.cpp
index 687f5b9e..c7b9ec0b 100644
--- a/src/bluetooth/qlowenergycontrollerbase.cpp
+++ b/src/bluetooth/qlowenergycontrollerbase.cpp
@@ -261,6 +261,8 @@ void QLowEnergyControllerPrivate::invalidateServices()
     }
 
     serviceList.clear();
+    localServices.clear();
+    lastLocalHandle = {};
 }
 
 QLowEnergyService *QLowEnergyControllerPrivate::addServiceHelper(
@@ -308,7 +310,12 @@ QLowEnergyService *QLowEnergyControllerPrivate::addServiceHelper(
         return nullptr;
     }
 
+    if (localServices.contains(servicePrivate->uuid)) {
+        qWarning() << "Overriding existing local service with uuid"
+                   << servicePrivate->uuid;
+    }
     this->localServices.insert(servicePrivate->uuid, servicePrivate);
+
     this->addToGenericAttributeList(service, servicePrivate->startHandle);
     return new QLowEnergyService(servicePrivate);
 }
diff --git a/src/bluetooth/qlowenergydescriptor.cpp b/src/bluetooth/qlowenergydescriptor.cpp
index 37a8f619..15859f17 100644
--- a/src/bluetooth/qlowenergydescriptor.cpp
+++ b/src/bluetooth/qlowenergydescriptor.cpp
@@ -54,14 +54,14 @@ QT_BEGIN_NAMESPACE
     QLowEnergyDescriptor provides information about a Bluetooth Low Energy
     descriptor's \l name(), \l uuid(), \l value() and \l handle(). Descriptors are
     encapsulated by Bluetooth Low Energy characteristics and provide additional
-    centextual information about the characteristic (data format, notification activation
+    contextual information about the characteristic (data format, notification activation
     and so on).
 
     The descriptor value may be written via the \l QLowEnergyService instance
     that manages the service to which this descriptor belongs. The
     \l {QLowEnergyService::writeDescriptor()} function writes the new value.
     The \l {QLowEnergyService::descriptorWritten()} signal
-    is emitted upon success. The cahced \l value() of this object is updated accordingly.
+    is emitted upon success. The cached \l value() of this object is updated accordingly.
 
     \sa QLowEnergyService, QLowEnergyCharacteristic
 */
diff --git a/src/bluetooth/qlowenergyservice.cpp b/src/bluetooth/qlowenergyservice.cpp
index 39de9d01..357d3901 100644
--- a/src/bluetooth/qlowenergyservice.cpp
+++ b/src/bluetooth/qlowenergyservice.cpp
@@ -75,7 +75,7 @@ QT_BEGIN_NAMESPACE
 
     \image peripheral-structure.png Structure of a generic peripheral
 
-    A characteristic is the principle information carrier. It has a
+    A characteristic is the principal information carrier. It has a
     \l {QLowEnergyCharacteristic::value()}{value()} and
     \l {QLowEnergyCharacteristic::value()}{properties()}
     describing the access permissions for the value. The general purpose
diff --git a/src/bluetooth/qlowenergyservice.h b/src/bluetooth/qlowenergyservice.h
index f413e7f7..9de65a84 100644
--- a/src/bluetooth/qlowenergyservice.h
+++ b/src/bluetooth/qlowenergyservice.h
@@ -47,7 +47,6 @@
 QT_BEGIN_NAMESPACE
 
 class QLowEnergyServicePrivate;
-class QLowEnergyControllerPrivateCommon;
 class Q_BLUETOOTH_EXPORT QLowEnergyService : public QObject
 {
     Q_OBJECT
diff --git a/src/imports/bluetooth/plugin.cpp b/src/imports/bluetooth/plugin.cpp
index 07654ca9..1e9737c6 100644
--- a/src/imports/bluetooth/plugin.cpp
+++ b/src/imports/bluetooth/plugin.cpp
@@ -45,13 +45,6 @@
 #include "qdeclarativebluetoothservice_p.h"
 #include "qdeclarativebluetoothsocket_p.h"
 
-static void initResources()
-{
-#ifdef QT_STATIC
-    Q_INIT_RESOURCE(qmake_QtBluetooth);
-#endif
-}
-
 QT_USE_NAMESPACE
 
 class QBluetoothQmlPlugin : public QQmlExtensionPlugin
@@ -59,7 +52,7 @@ class QBluetoothQmlPlugin : public QQmlExtensionPlugin
     Q_OBJECT
     Q_PLUGIN_METADATA(IID QQmlExtensionInterface_iid)
 public:
-    QBluetoothQmlPlugin(QObject *parent = 0) : QQmlExtensionPlugin(parent) { initResources(); }
+    QBluetoothQmlPlugin(QObject *parent = 0) : QQmlExtensionPlugin(parent) { }
     void registerTypes(const char *uri)
     {
         // @uri QtBluetooth
diff --git a/src/imports/bluetooth/plugins.qmltypes b/src/imports/bluetooth/plugins.qmltypes
index a00b0324..a22b950a 100644
--- a/src/imports/bluetooth/plugins.qmltypes
+++ b/src/imports/bluetooth/plugins.qmltypes
@@ -4,7 +4,7 @@ import QtQuick.tooling 1.2
 // It is used for QML tooling purposes only.
 //
 // This file was auto-generated by:
-// 'qmlplugindump -nonrelocatable QtBluetooth 5.10'
+// 'qmlplugindump -nonrelocatable QtBluetooth 5.11'
 
 Module {
     dependencies: ["QtQuick 2.8"]
diff --git a/src/imports/nfc/plugin.cpp b/src/imports/nfc/plugin.cpp
index 749e03d7..3a6806fa 100644
--- a/src/imports/nfc/plugin.cpp
+++ b/src/imports/nfc/plugin.cpp
@@ -47,13 +47,6 @@
 #include "qdeclarativendefurirecord_p.h"
 #include "qdeclarativendefmimerecord_p.h"
 
-static void initResources()
-{
-#ifdef QT_STATIC
-    Q_INIT_RESOURCE(qmake_QtNfc);
-#endif
-}
-
 QT_USE_NAMESPACE
 
 class QNfcQmlPlugin : public QQmlExtensionPlugin
@@ -62,7 +55,7 @@ class QNfcQmlPlugin : public QQmlExtensionPlugin
     Q_PLUGIN_METADATA(IID QQmlExtensionInterface_iid)
 
 public:
-    QNfcQmlPlugin(QObject *parent = 0) : QQmlExtensionPlugin(parent) { initResources(); }
+    QNfcQmlPlugin(QObject *parent = 0) : QQmlExtensionPlugin(parent) { }
     void registerTypes(const char *uri)
     {
         Q_ASSERT(uri == QStringLiteral("QtNfc"));
diff --git a/src/imports/nfc/plugins.qmltypes b/src/imports/nfc/plugins.qmltypes
index e6e98c24..4f723967 100644
--- a/src/imports/nfc/plugins.qmltypes
+++ b/src/imports/nfc/plugins.qmltypes
@@ -4,7 +4,7 @@ import QtQuick.tooling 1.2
 // It is used for QML tooling purposes only.
 //
 // This file was auto-generated by:
-// 'qmlplugindump -nonrelocatable QtNfc 5.10'
+// 'qmlplugindump -nonrelocatable QtNfc 5.11'
 
 Module {
     dependencies: ["QtQuick 2.8"]
diff --git a/src/imports/nfc/qdeclarativendeffilter.cpp b/src/imports/nfc/qdeclarativendeffilter.cpp
index 010be47f..6cbda747 100644
--- a/src/imports/nfc/qdeclarativendeffilter.cpp
+++ b/src/imports/nfc/qdeclarativendeffilter.cpp
@@ -78,7 +78,7 @@
 /*!
     \qmlproperty QQmlNdefRecord::TypeNameFormat NdefFilter::typeNameFormat
 
-    This property holds the NDEF record name format type \enum QQmlNdefRecord::TypeNameFormat.
+    This property holds the NDEF record name format type \l QQmlNdefRecord::TypeNameFormat.
 */
 
 /*!
diff --git a/src/nfc/android/androidjninfc.cpp b/src/nfc/android/androidjninfc.cpp
index f21d3b08..9a1c5227 100644
--- a/src/nfc/android/androidjninfc.cpp
+++ b/src/nfc/android/androidjninfc.cpp
@@ -63,6 +63,11 @@ bool isAvailable()
     return QAndroidJniObject::callStaticMethod<jboolean>(nfcClassName,"isAvailable");
 }
 
+bool isSupported()
+{
+    return QAndroidJniObject::callStaticMethod<jboolean>(nfcClassName,"isSupported");
+}
+
 bool stopDiscovery()
 {
     return QAndroidJniObject::callStaticMethod<jboolean>(nfcClassName,"stop");
diff --git a/src/nfc/android/androidjninfc_p.h b/src/nfc/android/androidjninfc_p.h
index 746a93ee..60e9a107 100644
--- a/src/nfc/android/androidjninfc_p.h
+++ b/src/nfc/android/androidjninfc_p.h
@@ -71,6 +71,7 @@ bool startDiscovery();
 bool stopDiscovery();
 QAndroidJniObject getStartIntent();
 bool isAvailable();
+bool isSupported();
 bool registerListener(AndroidNfcListenerInterface *listener);
 bool unregisterListener(AndroidNfcListenerInterface *listener);
 QAndroidJniObject getTag(const QAndroidJniObject &intent);
diff --git a/src/nfc/doc/src/nfc-index.qdoc b/src/nfc/doc/src/nfc-index.qdoc
index c9acc92b..21f775a6 100644
--- a/src/nfc/doc/src/nfc-index.qdoc
+++ b/src/nfc/doc/src/nfc-index.qdoc
@@ -60,6 +60,15 @@ import statement in your \c .qml file:
 
 \snippet doc_src_qtnfc.qml import
 
+\section1 Licenses
+
+Qt NFC is available under commercial licenses from \l{The Qt Company}.
+In addition, it is available under free software licenses. Since Qt 5.4,
+these free software licenses are
+\l{GNU Lesser General Public License, version 3}, or
+the \l{GNU General Public License, version 2}.
+See \l{Qt Licensing} for further details.
+
 \section1 Related Information
 
 \section2 Guides
diff --git a/src/nfc/doc/src/nfc-qml.qdoc b/src/nfc/doc/src/nfc-qml.qdoc
index 48df6d32..bbacb2de 100644
--- a/src/nfc/doc/src/nfc-qml.qdoc
+++ b/src/nfc/doc/src/nfc-qml.qdoc
@@ -28,7 +28,7 @@
 
 /*!
 
-\qmlmodule QtNfc 5.2
+\qmlmodule QtNfc 5.11
 \title Qt NFC QML Types
 \ingroup qmlmodules
 \brief Provides QML types for accessing NFC Forum Tags.
diff --git a/src/nfc/neard/neard_helper.cpp b/src/nfc/neard/neard_helper.cpp
index ef0447a0..9922c1a8 100644
--- a/src/nfc/neard/neard_helper.cpp
+++ b/src/nfc/neard/neard_helper.cpp
@@ -62,10 +62,10 @@ NeardHelper::NeardHelper(QObject *parent) :
         return;
     }
 
-    connect(m_dbusObjectManager, SIGNAL(InterfacesAdded(QDBusObjectPath,InterfaceList)),
-            this,                SLOT(interfacesAdded(QDBusObjectPath,InterfaceList)));
-    connect(m_dbusObjectManager, SIGNAL(InterfacesRemoved(QDBusObjectPath,QStringList)),
-            this,                SLOT(interfacesRemoved(QDBusObjectPath,QStringList)));
+    connect(m_dbusObjectManager, &OrgFreedesktopDBusObjectManagerInterface::InterfacesAdded,
+            this,                &NeardHelper::interfacesAdded);
+    connect(m_dbusObjectManager, &OrgFreedesktopDBusObjectManagerInterface::InterfacesRemoved,
+            this,                &NeardHelper::interfacesRemoved);
 }
 
 NeardHelper *NeardHelper::instance()
diff --git a/src/nfc/qllcpsocket_android_p.cpp b/src/nfc/qllcpsocket_android_p.cpp
index e29634d4..26b50c34 100644
--- a/src/nfc/qllcpsocket_android_p.cpp
+++ b/src/nfc/qllcpsocket_android_p.cpp
@@ -71,7 +71,7 @@ void QLlcpSocketPrivate::connectToService(QNearFieldTarget *target, const QStrin
     QNXNFCManager::instance()->registerLLCPConnection(m_conListener, this);
 
     qQNXNFCDebug() << "Connecting client socket" << serviceUri << m_conListener;
-    connect(QNXNFCManager::instance(), SIGNAL(llcpDisconnected()), this, SLOT(disconnectFromService()));*/
+    connect(QNXNFCManager::instance(), &QNXNFCManager::llcpDisconnected, this, &QLlcpSocketPrivate::disconnectFromService);*/
 }
 
 void QLlcpSocketPrivate::disconnectFromService()
@@ -83,7 +83,7 @@ void QLlcpSocketPrivate::disconnectFromService()
         qWarning() << Q_FUNC_INFO << "Error when trying to close LLCP socket";
     }
     QNXNFCManager::instance()->unregisterLLCPConnection(m_conListener);
-    disconnect(QNXNFCManager::instance(), SIGNAL(llcpDisconnected()), this, SLOT(disconnectFromService()));
+    disconnect(QNXNFCManager::instance(), &QNXNFCManager::llcpDisconnected, this, &QLlcpSocketPrivate::disconnectFromService);
 
     q->disconnected();
     m_conListener = 0;
@@ -96,7 +96,7 @@ bool QLlcpSocketPrivate::bind(quint8 port)
 
     /*m_state = QLlcpSocket::ConnectedState;
     m_server = true;
-    connect(QNXNFCManager::instance(), SIGNAL(llcpDisconnected()), this, SLOT(disconnectFromService()));
+    connect(QNXNFCManager::instance(), &QNXNFCManager::llcpDisconnected, this, &QLlcpSocketPrivate::disconnectFromService);
     connected(QNXNFCManager::instance()->getLastTarget());*/
 
     return true;
diff --git a/src/nfc/qndefnfctextrecord.cpp b/src/nfc/qndefnfctextrecord.cpp
index 78736cc0..95fb4c66 100644
--- a/src/nfc/qndefnfctextrecord.cpp
+++ b/src/nfc/qndefnfctextrecord.cpp
@@ -46,7 +46,7 @@ QT_BEGIN_NAMESPACE
 
 /*!
     \class QNdefNfcTextRecord
-    \brief The QNdefNfcTextRecord class provides an NFC RTD-Text
+    \brief The QNdefNfcTextRecord class provides an NFC RTD-Text.
 
     \ingroup connectivity-nfc
     \inmodule QtNfc
diff --git a/src/nfc/qndefnfcurirecord.cpp b/src/nfc/qndefnfcurirecord.cpp
index 44b17adf..3438d9f2 100644
--- a/src/nfc/qndefnfcurirecord.cpp
+++ b/src/nfc/qndefnfcurirecord.cpp
@@ -48,7 +48,7 @@ QT_BEGIN_NAMESPACE
 
 /*!
     \class QNdefNfcUriRecord
-    \brief The QNdefNfcUriRecord class provides an NFC RTD-URI
+    \brief The QNdefNfcUriRecord class provides an NFC RTD-URI.
 
     \ingroup connectivity-nfc
     \inmodule QtNfc
diff --git a/src/nfc/qnearfieldmanager.cpp b/src/nfc/qnearfieldmanager.cpp
index 099a070c..02e4d918 100644
--- a/src/nfc/qnearfieldmanager.cpp
+++ b/src/nfc/qnearfieldmanager.cpp
@@ -119,6 +119,19 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
+    \enum QNearFieldManager::AdapterState
+
+    \since 5.12
+
+    This enum describes the different states a NFC adapter can have.
+
+    \value Offline      The nfc adapter is offline.
+    \value TurningOn    The nfc adapter is turning on.
+    \value Online       The nfc adapter is online.
+    \value TurningOff   The nfc adapter is turning off.
+*/
+
+/*!
     \enum QNearFieldManager::TargetAccessMode
 
     This enum describes the different access modes an application can have.
@@ -133,6 +146,16 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
+    \fn void QNearFieldManager::adapterStateChanged(AdapterState state)
+
+    \since 5.12
+
+    This signal is emitted whenever the state of the NFC adapter changed.
+
+    \note Currently, this signal is only emitted on Android.
+*/
+
+/*!
     \fn void QNearFieldManager::targetDetected(QNearFieldTarget *target)
 
     This signal is emitted whenever a target is detected. The \a target parameter represents the
@@ -169,10 +192,14 @@ QT_BEGIN_NAMESPACE
 QNearFieldManager::QNearFieldManager(QObject *parent)
 :   QObject(parent), d_ptr(new QNearFieldManagerPrivateImpl)
 {
-    connect(d_ptr, SIGNAL(targetDetected(QNearFieldTarget*)),
-            this, SIGNAL(targetDetected(QNearFieldTarget*)));
-    connect(d_ptr, SIGNAL(targetLost(QNearFieldTarget*)),
-            this, SIGNAL(targetLost(QNearFieldTarget*)));
+    qRegisterMetaType<AdapterState>();
+
+    connect(d_ptr, &QNearFieldManagerPrivate::adapterStateChanged,
+            this, &QNearFieldManager::adapterStateChanged);
+    connect(d_ptr, &QNearFieldManagerPrivate::targetDetected,
+            this, &QNearFieldManager::targetDetected);
+    connect(d_ptr, &QNearFieldManagerPrivate::targetLost,
+            this, &QNearFieldManager::targetLost);
 }
 
 /*!
@@ -186,10 +213,14 @@ QNearFieldManager::QNearFieldManager(QObject *parent)
 QNearFieldManager::QNearFieldManager(QNearFieldManagerPrivate *backend, QObject *parent)
 :   QObject(parent), d_ptr(backend)
 {
-    connect(d_ptr, SIGNAL(targetDetected(QNearFieldTarget*)),
-            this, SIGNAL(targetDetected(QNearFieldTarget*)));
-    connect(d_ptr, SIGNAL(targetLost(QNearFieldTarget*)),
-            this, SIGNAL(targetLost(QNearFieldTarget*)));
+    qRegisterMetaType<AdapterState>();
+
+    connect(d_ptr, &QNearFieldManagerPrivate::adapterStateChanged,
+            this, &QNearFieldManager::adapterStateChanged);
+    connect(d_ptr, &QNearFieldManagerPrivate::targetDetected,
+            this, &QNearFieldManager::targetDetected);
+    connect(d_ptr, &QNearFieldManagerPrivate::targetLost,
+            this, &QNearFieldManager::targetLost);
 }
 
 /*!
@@ -201,7 +232,10 @@ QNearFieldManager::~QNearFieldManager()
 }
 
 /*!
-    Returns true if NFC functionality is available; otherwise returns false.
+    Returns \c true if the device has a NFC adapter and
+    it is turned on; otherwise returns \c false.
+
+    \sa isSupported()
 */
 bool QNearFieldManager::isAvailable() const
 {
@@ -211,6 +245,19 @@ bool QNearFieldManager::isAvailable() const
 }
 
 /*!
+    \since 5.12
+
+    Returns \c true if the underlying device has a NFC adapter; otherwise returns \c false.
+
+    \sa isAvailable()
+*/
+bool QNearFieldManager::isSupported() const
+{
+    Q_D(const QNearFieldManager);
+
+    return d->isSupported();
+}
+/*!
     \fn bool QNearFieldManager::startTargetDetection()
 
     Starts detecting targets and returns true if target detection is
diff --git a/src/nfc/qnearfieldmanager.h b/src/nfc/qnearfieldmanager.h
index 9583e01f..500b9631 100644
--- a/src/nfc/qnearfieldmanager.h
+++ b/src/nfc/qnearfieldmanager.h
@@ -56,6 +56,13 @@ class Q_NFC_EXPORT QNearFieldManager : public QObject
     Q_DECLARE_PRIVATE(QNearFieldManager)
 
 public:
+    enum class AdapterState {
+        Offline = 1,
+        TurningOn = 2,
+        Online = 3,
+        TurningOff = 4
+    };
+    Q_ENUM(AdapterState)
     enum TargetAccessMode {
         NoTargetAccess = 0x00,
         NdefReadTargetAccess = 0x01,
@@ -70,6 +77,7 @@ public:
     ~QNearFieldManager();
 
     bool isAvailable() const;
+    bool isSupported() const;
 
     void setTargetAccessModes(TargetAccessModes accessModes);
     TargetAccessModes targetAccessModes() const;
@@ -91,6 +99,7 @@ public:
     bool unregisterNdefMessageHandler(int handlerId);
 
 Q_SIGNALS:
+    void adapterStateChanged(AdapterState state);
     void targetDetected(QNearFieldTarget *target);
     void targetLost(QNearFieldTarget *target);
 
diff --git a/src/nfc/qnearfieldmanager_android.cpp b/src/nfc/qnearfieldmanager_android.cpp
index a5693218..297f8ef8 100644
--- a/src/nfc/qnearfieldmanager_android.cpp
+++ b/src/nfc/qnearfieldmanager_android.cpp
@@ -48,22 +48,52 @@
 #include "qdebug.h"
 #include "qlist.h"
 
+#include <QScopedPointer>
 #include <QtCore/QMetaType>
 #include <QtCore/QMetaMethod>
+#include <QtCore/private/qjnihelpers_p.h>
 
 QT_BEGIN_NAMESPACE
 
+Q_GLOBAL_STATIC(QAndroidJniObject, broadcastReceiver)
+Q_GLOBAL_STATIC(QList<QNearFieldManagerPrivateImpl *>, broadcastListener)
+
+extern "C"
+{
+    JNIEXPORT void JNICALL Java_org_qtproject_qt5_android_nfc_QtNfcBroadcastReceiver_jniOnReceive(
+        JNIEnv */*env*/, jobject /*javaObject*/, jint state)
+    {
+        QNearFieldManager::AdapterState adapterState = static_cast<QNearFieldManager::AdapterState>((int) state);
+
+        for (const auto listener : *broadcastListener) {
+            Q_EMIT listener->adapterStateChanged(adapterState);
+        }
+    }
+}
+
 QNearFieldManagerPrivateImpl::QNearFieldManagerPrivateImpl() :
     m_detecting(false), m_handlerID(0)
 {
     qRegisterMetaType<QAndroidJniObject>("QAndroidJniObject");
     qRegisterMetaType<QNdefMessage>("QNdefMessage");
-    connect(this, SIGNAL(targetDetected(QNearFieldTarget*)), this, SLOT(handlerTargetDetected(QNearFieldTarget*)));
-    connect(this, SIGNAL(targetLost(QNearFieldTarget*)), this, SLOT(handlerTargetLost(QNearFieldTarget*)));
+
+    if (!broadcastReceiver->isValid()) {
+        *broadcastReceiver = QAndroidJniObject("org/qtproject/qt5/android/nfc/QtNfcBroadcastReceiver",
+                                               "(Landroid/content/Context;)V", QtAndroidPrivate::context());
+    }
+    broadcastListener->append(this);
+
+    connect(this, &QNearFieldManagerPrivateImpl::targetDetected, this, &QNearFieldManagerPrivateImpl::handlerTargetDetected);
+    connect(this, &QNearFieldManagerPrivateImpl::targetLost, this, &QNearFieldManagerPrivateImpl::handlerTargetLost);
 }
 
 QNearFieldManagerPrivateImpl::~QNearFieldManagerPrivateImpl()
 {
+    broadcastListener->removeOne(this);
+    if (broadcastListener->isEmpty()) {
+        broadcastReceiver->callMethod<void>("unregisterReceiver");
+        *broadcastReceiver = QAndroidJniObject();
+    }
 }
 
 void QNearFieldManagerPrivateImpl::handlerTargetDetected(QNearFieldTarget *target)
@@ -71,12 +101,12 @@ void QNearFieldManagerPrivateImpl::handlerTargetDetected(QNearFieldTarget *targe
     if (ndefMessageHandlers.count() == 0 && ndefFilterHandlers.count() == 0) // if no handler is registered
         return;
     if (target->hasNdefMessage()) {
-        connect(target, SIGNAL(ndefMessageRead(const QNdefMessage &, const QNearFieldTarget::RequestId &)),
-                this, SLOT(handlerNdefMessageRead(const QNdefMessage &, const QNearFieldTarget::RequestId &)));
-        connect(target, SIGNAL(requestCompleted(const QNearFieldTarget::RequestId &)),
-                this, SLOT(handlerRequestCompleted(const QNearFieldTarget::RequestId &)));
-        connect(target, SIGNAL(error(QNearFieldTarget::Error, const QNearFieldTarget::RequestId &)),
-                this, SLOT(handlerError(QNearFieldTarget::Error, const QNearFieldTarget::RequestId &)));
+        connect(reinterpret_cast<NearFieldTarget *>(target), &NearFieldTarget::ndefMessageRead,
+                this, &QNearFieldManagerPrivateImpl::handlerNdefMessageRead);
+        connect(target, &QNearFieldTarget::requestCompleted,
+                this, &QNearFieldManagerPrivateImpl::handlerRequestCompleted);
+        connect(target, &QNearFieldTarget::error,
+                this, &QNearFieldManagerPrivateImpl::handlerError);
 
         QNearFieldTarget::RequestId id = target->readNdefMessages();
         m_idToTarget.insert(id, target);
@@ -85,12 +115,12 @@ void QNearFieldManagerPrivateImpl::handlerTargetDetected(QNearFieldTarget *targe
 
 void QNearFieldManagerPrivateImpl::handlerTargetLost(QNearFieldTarget *target)
 {
-    disconnect(target, SIGNAL(ndefMessageRead(const QNdefMessage &, const QNearFieldTarget::RequestId &)),
-            this, SLOT(handlerNdefMessageRead(const QNdefMessage &, const QNearFieldTarget::RequestId &)));
-    disconnect(target, SIGNAL(requestCompleted(const QNearFieldTarget::RequestId &)),
-            this, SLOT(handlerRequestCompleted(const QNearFieldTarget::RequestId &)));
-    disconnect(target, SIGNAL(error(QNearFieldTarget::Error, const QNearFieldTarget::RequestId &)),
-            this, SLOT(handlerError(QNearFieldTarget::Error, const QNearFieldTarget::RequestId &)));
+    disconnect(reinterpret_cast<NearFieldTarget *>(target), &NearFieldTarget::ndefMessageRead,
+            this, &QNearFieldManagerPrivateImpl::handlerNdefMessageRead);
+    disconnect(target, &QNearFieldTarget::requestCompleted,
+            this, &QNearFieldManagerPrivateImpl::handlerRequestCompleted);
+    disconnect(target, &QNearFieldTarget::error,
+            this, &QNearFieldManagerPrivateImpl::handlerError);
     m_idToTarget.remove(m_idToTarget.key(target));
 }
 
@@ -176,6 +206,11 @@ bool QNearFieldManagerPrivateImpl::isAvailable() const
     return AndroidNfc::isAvailable();
 }
 
+bool QNearFieldManagerPrivateImpl::isSupported() const
+{
+    return AndroidNfc::isSupported();
+}
+
 bool QNearFieldManagerPrivateImpl::startTargetDetection()
 {
     if (m_detecting)
@@ -282,8 +317,8 @@ void QNearFieldManagerPrivateImpl::onTargetDiscovered(QAndroidJniObject intent)
         target->setIntent(intent);  // Updating existing target
     } else {
         target = new NearFieldTarget(intent, uid, this);
-        connect(target, SIGNAL(targetDestroyed(QByteArray)), this, SLOT(onTargetDestroyed(QByteArray)));
-        connect(target, SIGNAL(targetLost(QNearFieldTarget*)), this, SIGNAL(targetLost(QNearFieldTarget*)));
+        connect(target, &NearFieldTarget::targetDestroyed, this, &QNearFieldManagerPrivateImpl::onTargetDestroyed);
+        connect(target, &NearFieldTarget::targetLost, this, &QNearFieldManagerPrivateImpl::targetLost);
     }
     emit targetDetected(target);
 }
diff --git a/src/nfc/qnearfieldmanager_android_p.h b/src/nfc/qnearfieldmanager_android_p.h
index 69c99709..563d26bc 100644
--- a/src/nfc/qnearfieldmanager_android_p.h
+++ b/src/nfc/qnearfieldmanager_android_p.h
@@ -76,6 +76,7 @@ public:
     ~QNearFieldManagerPrivateImpl();
 
     virtual bool isAvailable() const;
+    bool isSupported() const override;
     virtual bool startTargetDetection();
     virtual void stopTargetDetection();
     virtual int registerNdefMessageHandler(QObject *object, const QMetaMethod &method);
diff --git a/src/nfc/qnearfieldmanager_emulator.cpp b/src/nfc/qnearfieldmanager_emulator.cpp
index 3186bae5..c2c037f6 100644
--- a/src/nfc/qnearfieldmanager_emulator.cpp
+++ b/src/nfc/qnearfieldmanager_emulator.cpp
@@ -53,8 +53,8 @@ QNearFieldManagerPrivateImpl::QNearFieldManagerPrivateImpl()
 
     tagActivator->initialize();
 
-    connect(tagActivator, SIGNAL(tagActivated(TagBase*)), this, SLOT(tagActivated(TagBase*)));
-    connect(tagActivator, SIGNAL(tagDeactivated(TagBase*)), this, SLOT(tagDeactivated(TagBase*)));
+    connect(tagActivator, &TagActivator::tagActivated, this, &QNearFieldManagerPrivateImpl::tagActivated);
+    connect(tagActivator, &TagActivator::tagDeactivated, this, &QNearFieldManagerPrivateImpl::tagDeactivated);
 }
 
 QNearFieldManagerPrivateImpl::~QNearFieldManagerPrivateImpl()
diff --git a/src/nfc/qnearfieldmanager_neard.cpp b/src/nfc/qnearfieldmanager_neard.cpp
index f1758ae9..7c1c6e05 100644
--- a/src/nfc/qnearfieldmanager_neard.cpp
+++ b/src/nfc/qnearfieldmanager_neard.cpp
@@ -80,10 +80,10 @@ QNearFieldManagerPrivateImpl::QNearFieldManagerPrivateImpl()
     if (!found) {
         qCWarning(QT_NFC_NEARD) << "no adapter found, neard daemon running?";
     } else {
-        connect(m_neardHelper, SIGNAL(tagFound(QDBusObjectPath)),
-                this,          SLOT(handleTagFound(QDBusObjectPath)));
-        connect(m_neardHelper, SIGNAL(tagRemoved(QDBusObjectPath)),
-                this,          SLOT(handleTagRemoved(QDBusObjectPath)));
+        connect(m_neardHelper, &NeardHelper::tagFound,
+                this,          &QNearFieldManagerPrivateImpl::handleTagFound);
+        connect(m_neardHelper, &NeardHelper::tagRemoved,
+                this,          &QNearFieldManagerPrivateImpl::handleTagRemoved);
     }
 }
 
@@ -114,6 +114,21 @@ bool QNearFieldManagerPrivateImpl::isAvailable() const
     return false;
 }
 
+bool QNearFieldManagerPrivateImpl::isSupported() const
+{
+    if (m_adapterPath.isEmpty()) {
+        qCWarning(QT_NFC_NEARD) << "no adapter found, neard daemon running?";
+        return false;
+    }
+
+    if (!m_neardHelper->dbusObjectManager()->isValid() || m_adapterPath.isNull()) {
+        qCWarning(QT_NFC_NEARD) << "dbus object manager invalid or adapter path invalid";
+        return false;
+    }
+
+    return true;
+}
+
 bool QNearFieldManagerPrivateImpl::startTargetDetection()
 {
     qCDebug(QT_NFC_NEARD) << "starting target detection";
diff --git a/src/nfc/qnearfieldmanager_neard_p.h b/src/nfc/qnearfieldmanager_neard_p.h
index b50f947a..cf026982 100644
--- a/src/nfc/qnearfieldmanager_neard_p.h
+++ b/src/nfc/qnearfieldmanager_neard_p.h
@@ -75,6 +75,8 @@ public:
 
     bool isAvailable() const;
 
+    bool isSupported() const override;
+
     bool startTargetDetection();
 
     void stopTargetDetection();
diff --git a/src/nfc/qnearfieldmanager_p.h b/src/nfc/qnearfieldmanager_p.h
index 7e461da8..351c844a 100644
--- a/src/nfc/qnearfieldmanager_p.h
+++ b/src/nfc/qnearfieldmanager_p.h
@@ -82,6 +82,11 @@ public:
         return false;
     }
 
+    virtual bool isSupported() const
+    {
+        return false;
+    }
+
     virtual bool startTargetDetection()
     {
         return false;
@@ -124,6 +129,7 @@ public:
     }
 
 signals:
+    void adapterStateChanged(QNearFieldManager::AdapterState state);
     void targetDetected(QNearFieldTarget *target);
     void targetLost(QNearFieldTarget *target);
 
diff --git a/src/nfc/qnearfieldtagtype1.cpp b/src/nfc/qnearfieldtagtype1.cpp
index 34f2c8b8..7f27fbe9 100644
--- a/src/nfc/qnearfieldtagtype1.cpp
+++ b/src/nfc/qnearfieldtagtype1.cpp
@@ -440,9 +440,7 @@ QNearFieldTarget::RequestId QNearFieldTagType1::readNdefMessages()
     if (d->m_readNdefMessageState == QNearFieldTagType1Private::NotReadingNdefMessage) {
         d->progressToNextNdefReadMessageState();
     } else {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, NdefReadError),
-                                  Q_ARG(QNearFieldTarget::RequestId, d->m_readNdefRequestId));
+        reportError(QNearFieldTarget::NdefReadError, d->m_readNdefRequestId);
     }
 
     return d->m_readNdefRequestId;
@@ -462,9 +460,7 @@ QNearFieldTarget::RequestId QNearFieldTagType1::writeNdefMessages(const QList<QN
         d->m_ndefWriteMessages = messages;
         d->progressToNextNdefWriteMessageState();
     } else {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, NdefWriteError),
-                                  Q_ARG(QNearFieldTarget::RequestId, d->m_readNdefRequestId));
+        reportError(QNearFieldTarget::NdefWriteError, d->m_readNdefRequestId);
     }
 
     return d->m_writeNdefRequestId;
diff --git a/src/nfc/qnearfieldtarget.cpp b/src/nfc/qnearfieldtarget.cpp
index e642824b..e9a6fa11 100644
--- a/src/nfc/qnearfieldtarget.cpp
+++ b/src/nfc/qnearfieldtarget.cpp
@@ -530,4 +530,17 @@ bool QNearFieldTarget::handleResponse(const QNearFieldTarget::RequestId &id,
     return true;
 }
 
+/*!
+    \since 5.12
+
+    Reports the \a error for the request \a id by appending the signal emission to the event queue.
+*/
+void QNearFieldTarget::reportError(QNearFieldTarget::Error error,
+                                   const QNearFieldTarget::RequestId &id)
+{
+    QMetaObject::invokeMethod(this, [this, error, id]() {
+        Q_EMIT this->error(error, id);
+    }, Qt::QueuedConnection);
+}
+
 QT_END_NAMESPACE
diff --git a/src/nfc/qnearfieldtarget.h b/src/nfc/qnearfieldtarget.h
index e51960f7..868b52d5 100644
--- a/src/nfc/qnearfieldtarget.h
+++ b/src/nfc/qnearfieldtarget.h
@@ -153,6 +153,8 @@ protected:
     Q_INVOKABLE virtual bool handleResponse(const QNearFieldTarget::RequestId &id,
                                             const QByteArray &response);
 
+    void reportError(QNearFieldTarget::Error error, const QNearFieldTarget::RequestId &id);
+
 Q_SIGNALS:
     void disconnected();
 
diff --git a/src/nfc/qnearfieldtarget_android.cpp b/src/nfc/qnearfieldtarget_android.cpp
index 690fc272..78da6ac2 100644
--- a/src/nfc/qnearfieldtarget_android.cpp
+++ b/src/nfc/qnearfieldtarget_android.cpp
@@ -147,25 +147,19 @@ QNearFieldTarget::RequestId NearFieldTarget::readNdefMessages()
     // Making sure that target is still in range
     QNearFieldTarget::RequestId requestId(new QNearFieldTarget::RequestIdPrivate);
     if (!m_intent.isValid()) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, QNearFieldTarget::TargetOutOfRangeError),
-                                  Q_ARG(QNearFieldTarget::RequestId&, requestId));
+        reportError(QNearFieldTarget::TargetOutOfRangeError, requestId);
         return requestId;
     }
 
     // Getting Ndef technology object
     if (!setTagTechnology({NDEFTECHNOLOGY})) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, QNearFieldTarget::UnsupportedError),
-                                  Q_ARG(QNearFieldTarget::RequestId&, requestId));
+        reportError(QNearFieldTarget::UnsupportedError, requestId);
         return requestId;
     }
 
     // Connect
     if (!connect()) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, QNearFieldTarget::TargetOutOfRangeError),
-                                  Q_ARG(QNearFieldTarget::RequestId&, requestId));
+        reportError(QNearFieldTarget::TargetOutOfRangeError, requestId);
         return requestId;
     }
 
@@ -174,9 +168,7 @@ QNearFieldTarget::RequestId NearFieldTarget::readNdefMessages()
     if (catchJavaExceptions())
         ndefMessage = QAndroidJniObject();
     if (!ndefMessage.isValid()) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, QNearFieldTarget::NdefReadError),
-                                  Q_ARG(QNearFieldTarget::RequestId&, requestId));
+        reportError(QNearFieldTarget::NdefReadError, requestId);
         return requestId;
     }
 
@@ -191,13 +183,17 @@ QNearFieldTarget::RequestId NearFieldTarget::readNdefMessages()
 
     // Sending QNdefMessage, requestCompleted and exit.
     QNdefMessage qNdefMessage = QNdefMessage::fromByteArray(ndefMessageQBA);
-    QMetaObject::invokeMethod(this, "ndefMessageRead", Qt::QueuedConnection,
-                              Q_ARG(QNdefMessage&, qNdefMessage));
-    QMetaObject::invokeMethod(this, "requestCompleted", Qt::QueuedConnection,
-                              Q_ARG(QNearFieldTarget::RequestId&, requestId));
-    QMetaObject::invokeMethod(this, "ndefMessageRead", Qt::QueuedConnection,
-                              Q_ARG(QNdefMessage&, qNdefMessage),
-                              Q_ARG(QNearFieldTarget::RequestId&, requestId));
+    QMetaObject::invokeMethod(this, [this, qNdefMessage]() {
+        Q_EMIT this->QNearFieldTarget::ndefMessageRead(qNdefMessage);
+    }, Qt::QueuedConnection);
+    QMetaObject::invokeMethod(this, [this, requestId]() {
+        Q_EMIT this->requestCompleted(requestId);
+    }, Qt::QueuedConnection);
+    QMetaObject::invokeMethod(this, [this, qNdefMessage, requestId]() {
+        //TODO This is an Android specific signal in NearFieldTarget.
+        //     We need to check if it is still necessary.
+        Q_EMIT this->ndefMessageRead(qNdefMessage, requestId);
+    }, Qt::QueuedConnection);
     return requestId;
 }
 
@@ -245,9 +241,7 @@ QNearFieldTarget::RequestId NearFieldTarget::sendCommand(const QByteArray &comma
     // Connecting
     QNearFieldTarget::RequestId requestId = QNearFieldTarget::RequestId(new QNearFieldTarget::RequestIdPrivate());
     if (!connect()) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, QNearFieldTarget::TargetOutOfRangeError),
-                                  Q_ARG(QNearFieldTarget::RequestId&, requestId));
+        reportError(QNearFieldTarget::TargetOutOfRangeError, requestId);
         return requestId;
     }
 
@@ -259,9 +253,7 @@ QNearFieldTarget::RequestId NearFieldTarget::sendCommand(const QByteArray &comma
     // Writing
     QAndroidJniObject myNewVal = m_tagTech.callObjectMethod("transceive", "([B)[B", jba);
     if (catchJavaExceptions()) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, QNearFieldTarget::CommandError),
-                                  Q_ARG(QNearFieldTarget::RequestId&, requestId));
+        reportError(QNearFieldTarget::CommandError, requestId);
         return requestId;
     }
     QByteArray result = jbyteArrayToQByteArray(myNewVal.object<jbyteArray>());
@@ -273,8 +265,9 @@ QNearFieldTarget::RequestId NearFieldTarget::sendCommand(const QByteArray &comma
         // Closing connection
         disconnect();   // IOException at this point does not matter anymore.
     }
-    QMetaObject::invokeMethod(this, "requestCompleted", Qt::QueuedConnection,
-                              Q_ARG(QNearFieldTarget::RequestId&, requestId));
+    QMetaObject::invokeMethod(this, [this, requestId]() {
+        Q_EMIT this->requestCompleted(requestId);
+    }, Qt::QueuedConnection);
 
     return requestId;
 }
@@ -310,9 +303,7 @@ QNearFieldTarget::RequestId NearFieldTarget::writeNdefMessages(const QList<QNdef
     // Connecting
     QNearFieldTarget::RequestId requestId = QNearFieldTarget::RequestId(new QNearFieldTarget::RequestIdPrivate());
     if (!connect()) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, QNearFieldTarget::TargetOutOfRangeError),
-                                  Q_ARG(QNearFieldTarget::RequestId&, requestId));
+        reportError(QNearFieldTarget::TargetOutOfRangeError, requestId);
         return requestId;
     }
 
@@ -323,18 +314,14 @@ QNearFieldTarget::RequestId NearFieldTarget::writeNdefMessages(const QList<QNdef
     env->SetByteArrayRegion(jba.object<jbyteArray>(), 0, ba.size(), reinterpret_cast<jbyte*>(ba.data()));
     QAndroidJniObject jmessage = QAndroidJniObject("android/nfc/NdefMessage", "([B)V", jba.object<jbyteArray>());
     if (catchJavaExceptions()) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, QNearFieldTarget::UnknownError),
-                                  Q_ARG(QNearFieldTarget::RequestId&, requestId));
+        reportError(QNearFieldTarget::UnknownError, requestId);
         return requestId;
     }
 
     // Writing
     m_tagTech.callMethod<void>(writeMethod, "(Landroid/nfc/NdefMessage;)V", jmessage.object<jobject>());
     if (catchJavaExceptions()) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, QNearFieldTarget::NdefWriteError),
-                                  Q_ARG(QNearFieldTarget::RequestId&, requestId));
+        reportError(QNearFieldTarget::NdefWriteError, requestId);
         return requestId;
     }
 
diff --git a/src/nfc/qnearfieldtarget_emulator.cpp b/src/nfc/qnearfieldtarget_emulator.cpp
index 29b1f74d..030718cc 100644
--- a/src/nfc/qnearfieldtarget_emulator.cpp
+++ b/src/nfc/qnearfieldtarget_emulator.cpp
@@ -82,9 +82,7 @@ QNearFieldTarget::RequestId TagType1::sendCommand(const QByteArray &command)
 
     // tag not in proximity
     if (!tagMap.value(m_tag)) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, TargetOutOfRangeError),
-                                  Q_ARG(QNearFieldTarget::RequestId, id));
+        reportError(QNearFieldTarget::TargetOutOfRangeError, id);
         return id;
     }
 
@@ -93,17 +91,13 @@ QNearFieldTarget::RequestId TagType1::sendCommand(const QByteArray &command)
     QByteArray response = m_tag->processCommand(command + char(crc & 0xff) + char(crc >> 8));
 
     if (response.isEmpty()) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, NoResponseError),
-                                  Q_ARG(QNearFieldTarget::RequestId, id));
+        reportError(QNearFieldTarget::NoResponseError, id);
         return id;
     }
 
     // check crc
     if (qChecksum(response.constData(), response.length(), Qt::ChecksumItuV41) != 0) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, ChecksumMismatchError),
-                                  Q_ARG(QNearFieldTarget::RequestId, id));
+        reportError(QNearFieldTarget::ChecksumMismatchError, id);
         return id;
     }
 
@@ -152,9 +146,7 @@ QNearFieldTarget::RequestId TagType2::sendCommand(const QByteArray &command)
 
     // tag not in proximity
     if (!tagMap.value(m_tag)) {
-        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                  Q_ARG(QNearFieldTarget::Error, TargetOutOfRangeError),
-                                  Q_ARG(QNearFieldTarget::RequestId, id));
+        reportError(QNearFieldTarget::TargetOutOfRangeError, id);
         return id;
     }
 
@@ -168,9 +160,7 @@ QNearFieldTarget::RequestId TagType2::sendCommand(const QByteArray &command)
     if (response.length() > 1) {
         // check crc
         if (qChecksum(response.constData(), response.length(), Qt::ChecksumItuV41) != 0) {
-            QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                      Q_ARG(QNearFieldTarget::Error, ChecksumMismatchError),
-                                      Q_ARG(QNearFieldTarget::RequestId, id));
+            reportError(QNearFieldTarget::ChecksumMismatchError, id);
             return id;
         }
 
diff --git a/src/nfc/qnearfieldtarget_neard_p.h b/src/nfc/qnearfieldtarget_neard_p.h
index 78dedeeb..625cee67 100644
--- a/src/nfc/qnearfieldtarget_neard_p.h
+++ b/src/nfc/qnearfieldtarget_neard_p.h
@@ -355,12 +355,11 @@ private:
                 QMetaObject::invokeMethod(this, "ndefMessageRead", Qt::QueuedConnection,
                                           Q_ARG(QNdefMessage, newNdefMessage));
                 // the request id in requestCompleted has to match the one created in readNdefMessages
-                QMetaObject::invokeMethod(this, "requestCompleted", Qt::QueuedConnection,
-                                        Q_ARG(QNearFieldTarget::RequestId, m_currentReadRequestId));
+                QMetaObject::invokeMethod(this, [this]() {
+                    Q_EMIT this->requestCompleted(this->m_currentReadRequestId);
+                }, Qt::QueuedConnection);
             } else {
-                QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                          Q_ARG(QNearFieldTarget::Error, QNearFieldTarget::UnknownError),
-                                          Q_ARG(QNearFieldTarget::RequestId, m_currentReadRequestId));
+                this->reportError(QNearFieldTarget::UnknownError, m_currentReadRequestId);
             }
 
             m_readRequested = false;
@@ -388,14 +387,13 @@ private:
             reply.waitForFinished();
             if (reply.isError()) {
                 qCWarning(QT_NFC_NEARD) << "Error writing to NFC tag" << reply.error();
-                QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
-                                          Q_ARG(QNearFieldTarget::Error, QNearFieldTarget::UnknownError),
-                                          Q_ARG(QNearFieldTarget::RequestId, m_currentWriteRequestId));
+                this->reportError(QNearFieldTarget::UnknownError, m_currentWriteRequestId);
             }
 
             QMetaObject::invokeMethod(this, "ndefMessagesWritten", Qt::QueuedConnection);
-            QMetaObject::invokeMethod(this, "requestCompleted", Qt::QueuedConnection,
-                                      Q_ARG(QNearFieldTarget::RequestId, m_currentWriteRequestId));
+            QMetaObject::invokeMethod(this, [this]() {
+                Q_EMIT this->requestCompleted(this->m_currentWriteRequestId);
+            }, Qt::QueuedConnection);
         }
 
         // invalidate current write request