qlowenergycontroller_winrt.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qlowenergycontroller_winrt_p.h"
#include "qbluetoothutils_winrt_p.h"
 
#include <QtBluetooth/qbluetoothlocaldevice.h>
#include <QtBluetooth/QLowEnergyCharacteristicData>
#include <QtBluetooth/QLowEnergyDescriptorData>
#include <QtBluetooth/private/qbluetoothutils_winrt_p.h>
#include <QtBluetooth/QLowEnergyService>
 
#include <QtCore/QtEndian>
#include <QtCore/QLoggingCategory>
#include <QtCore/private/qfunctions_winrt_p.h>
#include <QtCore/QDeadlineTimer>
#include <QtCore/qpointer.h>
 
#include <functional>
 
#include <robuffer.h>
#include <windows.devices.enumeration.h>
#include <windows.devices.bluetooth.h>
#include <windows.devices.bluetooth.genericattributeprofile.h>
#include <windows.foundation.collections.h>
#include <windows.foundation.metadata.h>
#include <windows.storage.streams.h>
 
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;
using namespace ABI::Windows::Foundation;
using namespace ABI::Windows::Foundation::Collections;
using namespace ABI::Windows::Foundation::Metadata;
using namespace ABI::Windows::Devices;
using namespace ABI::Windows::Devices::Bluetooth;
using namespace ABI::Windows::Devices::Bluetooth::GenericAttributeProfile;
using namespace ABI::Windows::Devices::Enumeration;
using namespace ABI::Windows::Storage::Streams;
 
QT_BEGIN_NAMESPACE
 
typedef ITypedEventHandler<BluetoothLEDevice *, IInspectable *> StatusHandler;
typedef ITypedEventHandler<GattSession *, IInspectable *> MtuHandler;
typedef ITypedEventHandler<GattCharacteristic *, GattValueChangedEventArgs *> ValueChangedHandler;
typedef GattReadClientCharacteristicConfigurationDescriptorResult ClientCharConfigDescriptorResult;
typedef IGattReadClientCharacteristicConfigurationDescriptorResult IClientCharConfigDescriptorResult;
 
#define EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED(hr) \
    if (FAILED(hr)) { \
        emitErrorAndQuitThread(hr); \
        return; \
    }
 
#define EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, message) \
    if (FAILED(hr)) { \
        emitErrorAndQuitThread(message); \
        return; \
    }
 
#define WARN_AND_CONTINUE_IF_FAILED(hr, msg) \
    if (FAILED(hr)) { \
        qCWarning(QT_BT_WINDOWS) << msg; \
        continue; \
    }
 
#define DEC_CHAR_COUNT_AND_CONTINUE_IF_FAILED(hr, msg) \
    if (FAILED(hr)) { \
        qCWarning(QT_BT_WINDOWS) << msg; \
        --mCharacteristicsCountToBeDiscovered; \
        continue; \
    }
 
#define CHECK_FOR_DEVICE_CONNECTION_ERROR_IMPL(this, hr, msg, ret) \
    if (FAILED(hr)) { \
        this->handleConnectionError(msg); \
        ret; \
    }
 
#define CHECK_FOR_DEVICE_CONNECTION_ERROR(hr, msg, ret) \
    CHECK_FOR_DEVICE_CONNECTION_ERROR_IMPL(this, hr, msg, ret)
 
#define CHECK_HR_AND_SET_SERVICE_ERROR(hr, msg, service, error, ret) \
    if (FAILED(hr)) { \
        qCDebug(QT_BT_WINDOWS) << msg; \
        service->setError(error); \
        ret; \
    }
 
Q_DECLARE_LOGGING_CATEGORY(QT_BT_WINDOWS)
Q_DECLARE_LOGGING_CATEGORY(QT_BT_WINDOWS_SERVICE_THREAD)
 
static constexpr qint64 kMaxConnectTimeout = 20000; // 20 sec
 
static QByteArray byteArrayFromGattResult(const ComPtr<IGattReadResult> &gattResult,
                                          bool isWCharString = false)
{
    ComPtr<ABI::Windows::Storage::Streams::IBuffer> buffer;
    HRESULT hr;
    hr = gattResult->get_Value(&buffer);
    if (FAILED(hr) || !buffer) {
        qCWarning(QT_BT_WINDOWS) << "Could not obtain buffer from GattReadResult";
        return QByteArray();
    }
    return byteArrayFromBuffer(buffer, isWCharString);
}
 
template <typename T>
static void closeDeviceService(ComPtr<T> service)
{
    ComPtr<IClosable> closableService;
    HRESULT hr = service.As(&closableService);
    RETURN_IF_FAILED("Could not cast type to closable", return);
    hr = closableService->Close();
    RETURN_IF_FAILED("Close() call failed", return);
}
 
class QWinRTLowEnergyServiceHandler : public QObject
{
    Q_OBJECT
public:
    QWinRTLowEnergyServiceHandler(const QBluetoothUuid &service,
                                     const ComPtr<IGattDeviceService3> &deviceService,
                                     QLowEnergyService::DiscoveryMode mode)
        : mService(service), mMode(mode), mDeviceService(deviceService)
    {
        qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
    }
 
    ~QWinRTLowEnergyServiceHandler()
    {
        if (mAbortRequested)
            closeDeviceService(mDeviceService);
        qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
    }
 
public slots:
    void obtainCharList()
    {
        auto exitCondition = [this]() { return mAbortRequested; };
 
        mIndicateChars.clear();
        qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
        ComPtr<IAsyncOperation<GattCharacteristicsResult *>> characteristicsOp;
        ComPtr<IGattCharacteristicsResult> characteristicsResult;
        HRESULT hr = mDeviceService->GetCharacteristicsAsync(&characteristicsOp);
        EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED(hr);
        hr = QWinRTFunctions::await(characteristicsOp, characteristicsResult.GetAddressOf(),
                                    QWinRTFunctions::ProcessMainThreadEvents, 5000,
                                    exitCondition);
        EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED(hr);
        GattCommunicationStatus status;
        hr = characteristicsResult->get_Status(&status);
        EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED(hr);
        if (status != GattCommunicationStatus_Success) {
            emitErrorAndQuitThread(QLatin1String("Could not obtain char list"));
            return;
        }
        ComPtr<IVectorView<GattCharacteristic *>> characteristics;
        hr = characteristicsResult->get_Characteristics(&characteristics);
        EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED(hr);
 
        uint characteristicsCount;
        hr = characteristics->get_Size(&characteristicsCount);
        EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED(hr);
 
        mCharacteristicsCountToBeDiscovered = characteristicsCount;
        for (uint i = 0; !mAbortRequested && (i < characteristicsCount); ++i) {
            ComPtr<IGattCharacteristic> characteristic;
            hr = characteristics->GetAt(i, &characteristic);
            if (FAILED(hr)) {
                qCWarning(QT_BT_WINDOWS) << "Could not obtain characteristic at" << i;
                --mCharacteristicsCountToBeDiscovered;
                continue;
            }
 
            ComPtr<IGattCharacteristic3> characteristic3;
            hr = characteristic.As(&characteristic3);
            if (FAILED(hr)) {
                qCWarning(QT_BT_WINDOWS) << "Could not cast characteristic";
                --mCharacteristicsCountToBeDiscovered;
                continue;
            }
 
            // For some strange reason, Windows doesn't discover descriptors of characteristics (if not paired).
            // Qt API assumes that all characteristics and their descriptors are discovered in one go.
            // So we start 'GetDescriptorsAsync' for each discovered characteristic and finish only
            // when GetDescriptorsAsync for all characteristics return.
            ComPtr<IAsyncOperation<GattDescriptorsResult *>> descAsyncOp;
            hr = characteristic3->GetDescriptorsAsync(&descAsyncOp);
            DEC_CHAR_COUNT_AND_CONTINUE_IF_FAILED(hr, "Could not obtain list of descriptors")
 
            ComPtr<IGattDescriptorsResult> descResult;
            hr = QWinRTFunctions::await(descAsyncOp, descResult.GetAddressOf(),
                                        QWinRTFunctions::ProcessMainThreadEvents, 5000,
                                        exitCondition);
            DEC_CHAR_COUNT_AND_CONTINUE_IF_FAILED(hr, "Could not obtain descriptor read result")
 
            quint16 handle;
            hr = characteristic->get_AttributeHandle(&handle);
            DEC_CHAR_COUNT_AND_CONTINUE_IF_FAILED(
                    hr, "Could not obtain characteristic's attribute handle")
            QLowEnergyServicePrivate::CharData charData;
            charData.valueHandle = handle + 1;
            if (mStartHandle == 0 || mStartHandle > handle)
                mStartHandle = handle;
            if (mEndHandle == 0 || mEndHandle < handle)
                mEndHandle = handle;
            GUID guuid;
            hr = characteristic->get_Uuid(&guuid);
            DEC_CHAR_COUNT_AND_CONTINUE_IF_FAILED(hr, "Could not obtain characteristic's Uuid")
            charData.uuid = QBluetoothUuid(guuid);
            GattCharacteristicProperties properties;
            hr = characteristic->get_CharacteristicProperties(&properties);
            DEC_CHAR_COUNT_AND_CONTINUE_IF_FAILED(hr,
                                                  "Could not obtain characteristic's properties")
            charData.properties = QLowEnergyCharacteristic::PropertyTypes(properties & 0xff);
            if (charData.properties & QLowEnergyCharacteristic::Read
                && mMode == QLowEnergyService::FullDiscovery) {
                ComPtr<IAsyncOperation<GattReadResult *>> readOp;
                hr = characteristic->ReadValueWithCacheModeAsync(BluetoothCacheMode_Uncached,
                                                                 &readOp);
                DEC_CHAR_COUNT_AND_CONTINUE_IF_FAILED(hr, "Could not read characteristic")
                ComPtr<IGattReadResult> readResult;
                hr = QWinRTFunctions::await(readOp, readResult.GetAddressOf(),
                                            QWinRTFunctions::ProcessMainThreadEvents, 5000,
                                            exitCondition);
                DEC_CHAR_COUNT_AND_CONTINUE_IF_FAILED(hr,
                                                      "Could not obtain characteristic read result")
                if (!readResult)
                    qCWarning(QT_BT_WINDOWS) << "Characteristic read result is null";
                else
                    charData.value = byteArrayFromGattResult(readResult);
            }
            mCharacteristicList.insert(handle, charData);
 
            ComPtr<IVectorView<GattDescriptor *>> descriptors;
 
            GattCommunicationStatus commStatus;
            hr = descResult->get_Status(&commStatus);
            if (FAILED(hr) || commStatus != GattCommunicationStatus_Success) {
                qCWarning(QT_BT_WINDOWS) << "Descriptor operation failed";
                --mCharacteristicsCountToBeDiscovered;
                continue;
            }
 
            hr = descResult->get_Descriptors(&descriptors);
            DEC_CHAR_COUNT_AND_CONTINUE_IF_FAILED(hr, "Could not obtain list of descriptors")
 
            uint descriptorCount;
            hr = descriptors->get_Size(&descriptorCount);
            DEC_CHAR_COUNT_AND_CONTINUE_IF_FAILED(hr, "Could not obtain list of descriptors' size")
            for (uint j = 0; !mAbortRequested && (j < descriptorCount); ++j) {
                QLowEnergyServicePrivate::DescData descData;
                ComPtr<IGattDescriptor> descriptor;
                hr = descriptors->GetAt(j, &descriptor);
                WARN_AND_CONTINUE_IF_FAILED(hr, "Could not obtain descriptor")
                quint16 descHandle;
                hr = descriptor->get_AttributeHandle(&descHandle);
                WARN_AND_CONTINUE_IF_FAILED(hr, "Could not obtain descriptor's attribute handle")
                GUID descriptorUuid;
                hr = descriptor->get_Uuid(&descriptorUuid);
                WARN_AND_CONTINUE_IF_FAILED(hr, "Could not obtain descriptor's Uuid")
                descData.uuid = QBluetoothUuid(descriptorUuid);
                charData.descriptorList.insert(descHandle, descData);
                if (descData.uuid == QBluetoothUuid(QBluetoothUuid::DescriptorType::ClientCharacteristicConfiguration)) {
                    if (mMode == QLowEnergyService::FullDiscovery) {
                        ComPtr<IAsyncOperation<ClientCharConfigDescriptorResult *>> readOp;
                        hr = characteristic->ReadClientCharacteristicConfigurationDescriptorAsync(
                                &readOp);
                        WARN_AND_CONTINUE_IF_FAILED(hr, "Could not read descriptor value")
                        ComPtr<IClientCharConfigDescriptorResult> readResult;
                        hr = QWinRTFunctions::await(readOp, readResult.GetAddressOf(),
                                                    QWinRTFunctions::ProcessMainThreadEvents, 5000,
                                                    exitCondition);
                        WARN_AND_CONTINUE_IF_FAILED(hr, "Could not await descriptor read result")
                        GattClientCharacteristicConfigurationDescriptorValue value;
                        hr = readResult->get_ClientCharacteristicConfigurationDescriptor(&value);
                        WARN_AND_CONTINUE_IF_FAILED(hr,
                                                    "Could not get descriptor value from result")
                        quint16 result = 0;
                        bool correct = false;
                        if (value & GattClientCharacteristicConfigurationDescriptorValue_Indicate) {
                            result |= GattClientCharacteristicConfigurationDescriptorValue_Indicate;
                            correct = true;
                        }
                        if (value & GattClientCharacteristicConfigurationDescriptorValue_Notify) {
                            result |= GattClientCharacteristicConfigurationDescriptorValue_Notify;
                            correct = true;
                        }
                        if (value == GattClientCharacteristicConfigurationDescriptorValue_None)
                            correct = true;
                        if (!correct)
                            continue;
 
                        descData.value = QByteArray(2, Qt::Uninitialized);
                        qToLittleEndian(result, descData.value.data());
                    }
                    mIndicateChars << charData.uuid;
                } else {
                    if (mMode == QLowEnergyService::FullDiscovery) {
                        ComPtr<IAsyncOperation<GattReadResult *>> readOp;
                        hr = descriptor->ReadValueWithCacheModeAsync(BluetoothCacheMode_Uncached,
                                                                     &readOp);
                        WARN_AND_CONTINUE_IF_FAILED(hr, "Could not read descriptor value")
                        ComPtr<IGattReadResult> readResult;
                        hr = QWinRTFunctions::await(readOp, readResult.GetAddressOf(),
                                                    QWinRTFunctions::ProcessMainThreadEvents, 5000,
                                                    exitCondition);
                        WARN_AND_CONTINUE_IF_FAILED(hr, "Could not await descriptor read result")
                        if (descData.uuid == QBluetoothUuid::DescriptorType::CharacteristicUserDescription)
                            descData.value = byteArrayFromGattResult(readResult, true);
                        else
                            descData.value = byteArrayFromGattResult(readResult);
                    }
                }
                charData.descriptorList.insert(descHandle, descData);
            }
 
            mCharacteristicList.insert(handle, charData);
            --mCharacteristicsCountToBeDiscovered;
        }
        checkAllCharacteristicsDiscovered();
    }
 
    void setAbortRequested()
    {
        mAbortRequested = true;
    }
 
private:
    void checkAllCharacteristicsDiscovered();
    void emitErrorAndQuitThread(HRESULT hr);
    void emitErrorAndQuitThread(const QString &error);
 
public:
    QBluetoothUuid mService;
    QLowEnergyService::DiscoveryMode mMode;
    ComPtr<IGattDeviceService3> mDeviceService;
    QHash<QLowEnergyHandle, QLowEnergyServicePrivate::CharData> mCharacteristicList;
    uint mCharacteristicsCountToBeDiscovered;
    quint16 mStartHandle = 0;
    quint16 mEndHandle = 0;
    QList<QBluetoothUuid> mIndicateChars;
    bool mAbortRequested = false;
 
signals:
    void charListObtained(const QBluetoothUuid &service,
                          QHash<QLowEnergyHandle, QLowEnergyServicePrivate::CharData> charList,
                          QList<QBluetoothUuid> indicateChars, QLowEnergyHandle startHandle,
                          QLowEnergyHandle endHandle);
    void errorOccured(const QString &error);
};
 
void QWinRTLowEnergyServiceHandler::checkAllCharacteristicsDiscovered()
{
    if (!mAbortRequested && (mCharacteristicsCountToBeDiscovered == 0)) {
        emit charListObtained(mService, mCharacteristicList, mIndicateChars,
                              mStartHandle, mEndHandle);
    }
    QThread::currentThread()->quit();
}
 
void QWinRTLowEnergyServiceHandler::emitErrorAndQuitThread(HRESULT hr)
{
    emitErrorAndQuitThread(qt_error_string(hr));
}
 
void QWinRTLowEnergyServiceHandler::emitErrorAndQuitThread(const QString &error)
{
    mAbortRequested = true; // so that the service is closed during cleanup
    emit errorOccured(error);
    QThread::currentThread()->quit();
}
 
class QWinRTLowEnergyConnectionHandler : public QObject
{
    Q_OBJECT
public:
    explicit QWinRTLowEnergyConnectionHandler(const QBluetoothAddress &address) : mAddress(address)
    {
        qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
        // This should be checked before the handler is created
        Q_ASSERT(!mAddress.isNull());
    }
    ~QWinRTLowEnergyConnectionHandler()
    {
        qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
        mDevice.Reset();
        mGattSession.Reset();
        // To close the COM library gracefully, each successful call to
        // CoInitialize, including those that return S_FALSE, must be balanced
        // by a corresponding call to CoUninitialize.
        if (mInitialized == S_OK || mInitialized == S_FALSE)
            CoUninitialize();
    }
 
public slots:
    void connectToDevice();
    void handleDeviceDisconnectRequest();
 
signals:
    void deviceConnected(ComPtr<IBluetoothLEDevice> device, ComPtr<IGattSession> session);
    void errorOccurred(const QString &error);
 
private:
    void connectToPairedDevice();
    void connectToUnpairedDevice();
    void emitErrorAndQuitThread(const QString &error);
    void emitErrorAndQuitThread(const char *error);
    void emitConnectedAndQuitThread();
 
    ComPtr<IBluetoothLEDevice> mDevice = nullptr;
    ComPtr<IGattSession> mGattSession = nullptr;
    const QBluetoothAddress mAddress;
    bool mAbortConnection = false;
    HRESULT mInitialized = E_UNEXPECTED; // some error code
};
 
void QWinRTLowEnergyConnectionHandler::connectToDevice()
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
    mInitialized = CoInitializeEx(NULL, COINIT_MULTITHREADED);
    qCDebug(QT_BT_WINDOWS) << qt_error_string(mInitialized);
 
    auto earlyExit = [this]() { return mAbortConnection; };
    ComPtr<IBluetoothLEDeviceStatics> deviceStatics;
    HRESULT hr = GetActivationFactory(
            HString::MakeReference(RuntimeClass_Windows_Devices_Bluetooth_BluetoothLEDevice).Get(),
            &deviceStatics);
    EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not obtain device factory");
    ComPtr<IAsyncOperation<BluetoothLEDevice *>> deviceFromIdOperation;
    hr = deviceStatics->FromBluetoothAddressAsync(mAddress.toUInt64(), &deviceFromIdOperation);
    EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not find LE device from address");
    hr = QWinRTFunctions::await(deviceFromIdOperation, mDevice.GetAddressOf(),
                                QWinRTFunctions::ProcessMainThreadEvents, 5000, earlyExit);
    if (FAILED(hr) || !mDevice) {
        emitErrorAndQuitThread("Could not find LE device");
        return;
    }
 
    // get GattSession: 1. get device id
    ComPtr<IBluetoothLEDevice4> device4;
    hr = mDevice.As(&device4);
    EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not cast device");
 
    ComPtr<IBluetoothDeviceId> deviceId;
    hr = device4->get_BluetoothDeviceId(&deviceId);
    EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not get bluetooth device id");
 
    // get GattSession: 2. get session statics
    ComPtr<IGattSessionStatics> sessionStatics;
    hr = GetActivationFactory(
            HString::MakeReference(
                    RuntimeClass_Windows_Devices_Bluetooth_GenericAttributeProfile_GattSession)
                    .Get(),
            &sessionStatics);
    EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not obtain GattSession statics");
 
    // get GattSession: 3. get session
    ComPtr<IAsyncOperation<GattSession *>> gattSessionFromIdOperation;
    hr = sessionStatics->FromDeviceIdAsync(deviceId.Get(), &gattSessionFromIdOperation);
    EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not get GattSession from id");
    hr = QWinRTFunctions::await(gattSessionFromIdOperation, mGattSession.GetAddressOf(),
                                QWinRTFunctions::ProcessMainThreadEvents, 5000, earlyExit);
    EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not complete Gatt session acquire");
 
    BluetoothConnectionStatus status;
    hr = mDevice->get_ConnectionStatus(&status);
    EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not obtain device's connection status");
    if (status == BluetoothConnectionStatus::BluetoothConnectionStatus_Connected) {
        emitConnectedAndQuitThread();
        return;
    }
 
    QBluetoothLocalDevice localDevice;
    QBluetoothLocalDevice::Pairing pairing = localDevice.pairingStatus(mAddress);
    if (pairing == QBluetoothLocalDevice::Unpaired)
        connectToUnpairedDevice();
    else
        connectToPairedDevice();
}
 
void QWinRTLowEnergyConnectionHandler::handleDeviceDisconnectRequest()
{
    mAbortConnection = true;
    // Disconnect from the QLowEnergyControllerPrivateWinRT, so that it does
    // not get notifications. It's absolutely fine to keep doing smth in
    // background, as multiple connections to the same device should be handled
    // correctly by OS.
    disconnect(this, &QWinRTLowEnergyConnectionHandler::deviceConnected, nullptr, nullptr);
    disconnect(this, &QWinRTLowEnergyConnectionHandler::errorOccurred, nullptr, nullptr);
}
 
void QWinRTLowEnergyConnectionHandler::connectToPairedDevice()
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
    ComPtr<IBluetoothLEDevice3> device3;
    HRESULT hr = mDevice.As(&device3);
    EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not cast device");
    ComPtr<IAsyncOperation<GattDeviceServicesResult *>> deviceServicesOp;
    auto earlyExit = [this]() { return mAbortConnection; };
    QDeadlineTimer deadline(kMaxConnectTimeout);
    while (!mAbortConnection && !deadline.hasExpired()) {
        hr = device3->GetGattServicesAsync(&deviceServicesOp);
        EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not obtain services");
        ComPtr<IGattDeviceServicesResult> deviceServicesResult;
        hr = QWinRTFunctions::await(deviceServicesOp, deviceServicesResult.GetAddressOf(),
                                    QWinRTFunctions::ProcessThreadEvents, 5000, earlyExit);
        EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not await services operation");
 
        GattCommunicationStatus commStatus;
        hr = deviceServicesResult->get_Status(&commStatus);
        if (FAILED(hr) || commStatus != GattCommunicationStatus_Success) {
            emitErrorAndQuitThread("Service operation failed");
            return;
        }
 
        ComPtr<IVectorView<GattDeviceService *>> deviceServices;
        hr = deviceServicesResult->get_Services(&deviceServices);
        EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not obtain list of services");
        uint serviceCount;
        hr = deviceServices->get_Size(&serviceCount);
        EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not obtain service count");
 
        if (serviceCount == 0) {
            emitErrorAndQuitThread("Found devices without services");
            return;
        }
 
        // Windows automatically connects to the device as soon as a service value is read/written.
        // Thus we read one value in order to establish the connection.
        for (uint i = 0; i < serviceCount; ++i) {
            ComPtr<IGattDeviceService> service;
            hr = deviceServices->GetAt(i, &service);
            EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not obtain service");
            ComPtr<IGattDeviceService3> service3;
            hr = service.As(&service3);
            EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not cast service");
            ComPtr<IAsyncOperation<GattCharacteristicsResult *>> characteristicsOp;
            hr = service3->GetCharacteristicsAsync(&characteristicsOp);
            EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not obtain characteristic");
            ComPtr<IGattCharacteristicsResult> characteristicsResult;
            hr = QWinRTFunctions::await(characteristicsOp, characteristicsResult.GetAddressOf(),
                                        QWinRTFunctions::ProcessThreadEvents, 5000, earlyExit);
            EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not await characteristic operation");
            GattCommunicationStatus commStatus;
            hr = characteristicsResult->get_Status(&commStatus);
            if (FAILED(hr) || commStatus != GattCommunicationStatus_Success) {
                qCWarning(QT_BT_WINDOWS) << "Characteristic operation failed";
                break;
            }
            ComPtr<IVectorView<GattCharacteristic *>> characteristics;
            hr = characteristicsResult->get_Characteristics(&characteristics);
            if (hr == E_ACCESSDENIED) {
                // Everything will work as expected up until this point if the
                // manifest capabilties for bluetooth LE are not set.
                emitErrorAndQuitThread("Could not obtain characteristic list. "
                                       "Please check your manifest capabilities");
                return;
            }
            EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not obtain characteristic list");
            uint characteristicsCount;
            hr = characteristics->get_Size(&characteristicsCount);
            EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr,
                                                   "Could not obtain characteristic list's size");
            for (uint j = 0; j < characteristicsCount; ++j) {
                ComPtr<IGattCharacteristic> characteristic;
                hr = characteristics->GetAt(j, &characteristic);
                EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not obtain characteristic");
                ComPtr<IAsyncOperation<GattReadResult *>> op;
                GattCharacteristicProperties props;
                hr = characteristic->get_CharacteristicProperties(&props);
                EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(
                        hr, "Could not obtain characteristic's properties");
                if (!(props & GattCharacteristicProperties_Read))
                    continue;
                hr = characteristic->ReadValueWithCacheModeAsync(
                        BluetoothCacheMode::BluetoothCacheMode_Uncached, &op);
                EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not read characteristic value");
                ComPtr<IGattReadResult> result;
                // Reading characteristics can take surprisingly long at the
                // first time, so we need to have a large the timeout here.
                hr = QWinRTFunctions::await(op, result.GetAddressOf(),
                                            QWinRTFunctions::ProcessThreadEvents, 5000, earlyExit);
                // E_ILLEGAL_METHOD_CALL will be the result for a device, that is not reachable at
                // the moment. In this case we should jump back into the outer loop and keep trying.
                if (hr == E_ILLEGAL_METHOD_CALL)
                    break;
                EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not await characteristic read");
                ComPtr<ABI::Windows::Storage::Streams::IBuffer> buffer;
                hr = result->get_Value(&buffer);
                EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not obtain characteristic value");
                if (!buffer) {
                    qCDebug(QT_BT_WINDOWS) << "Problem reading value";
                    break;
                }
 
                emitConnectedAndQuitThread();
                return;
            }
        }
    }
    // If we got here because of mAbortConnection == true, the error message
    // will not be delivered, so it does not matter. But we need to terminate
    // the thread anyway!
    emitErrorAndQuitThread("Connect to device failed due to timeout!");
}
 
void QWinRTLowEnergyConnectionHandler::connectToUnpairedDevice()
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
    ComPtr<IBluetoothLEDevice3> device3;
    HRESULT hr = mDevice.As(&device3);
    EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not cast device");
    ComPtr<IGattDeviceServicesResult> deviceServicesResult;
    auto earlyExit = [this]() { return mAbortConnection; };
    QDeadlineTimer deadline(kMaxConnectTimeout);
    while (!mAbortConnection && !deadline.hasExpired()) {
        ComPtr<IAsyncOperation<GattDeviceServicesResult *>> deviceServicesOp;
        hr = device3->GetGattServicesAsync(&deviceServicesOp);
        EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not obtain services");
        hr = QWinRTFunctions::await(deviceServicesOp, deviceServicesResult.GetAddressOf(),
                                    QWinRTFunctions::ProcessMainThreadEvents, 0, earlyExit);
        EMIT_WORKER_ERROR_AND_QUIT_IF_FAILED_2(hr, "Could not await services operation");
 
        GattCommunicationStatus commStatus;
        hr = deviceServicesResult->get_Status(&commStatus);
        if (commStatus == GattCommunicationStatus_Unreachable)
            continue;
 
        if (FAILED(hr) || commStatus != GattCommunicationStatus_Success) {
            emitErrorAndQuitThread("Service operation failed");
            return;
        }
 
        emitConnectedAndQuitThread();
        return;
    }
    // If we got here because of mAbortConnection == true, the error message
    // will not be delivered, so it does not matter. But we need to terminate
    // the thread anyway!
    emitErrorAndQuitThread("Connect to device failed due to timeout!");
}
 
void QWinRTLowEnergyConnectionHandler::emitErrorAndQuitThread(const QString &error)
{
    emit errorOccurred(error);
    QThread::currentThread()->quit();
}
 
void QWinRTLowEnergyConnectionHandler::emitErrorAndQuitThread(const char *error)
{
    emitErrorAndQuitThread(QString::fromUtf8(error));
}
 
void QWinRTLowEnergyConnectionHandler::emitConnectedAndQuitThread()
{
    emit deviceConnected(mDevice, mGattSession);
    QThread::currentThread()->quit();
}
 
QLowEnergyControllerPrivateWinRT::QLowEnergyControllerPrivateWinRT()
    : QLowEnergyControllerPrivate()
{
    registerQLowEnergyControllerMetaType();
    connect(this, &QLowEnergyControllerPrivateWinRT::characteristicChanged,
            this, &QLowEnergyControllerPrivateWinRT::handleCharacteristicChanged,
            Qt::QueuedConnection);
}
 
QLowEnergyControllerPrivateWinRT::~QLowEnergyControllerPrivateWinRT()
{
    unregisterFromStatusChanges();
    unregisterFromValueChanges();
}
 
void QLowEnergyControllerPrivateWinRT::init()
{
}
 
void QLowEnergyControllerPrivateWinRT::connectToDevice()
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
    if (remoteDevice.isNull()) {
        qCWarning(QT_BT_WINDOWS) << "Invalid/null remote device address";
        setError(QLowEnergyController::UnknownRemoteDeviceError);
        return;
    }
    setState(QLowEnergyController::ConnectingState);
 
    QWinRTLowEnergyConnectionHandler *worker = new QWinRTLowEnergyConnectionHandler(remoteDevice);
    QThread *thread = new QThread;
    worker->moveToThread(thread);
    connect(this, &QLowEnergyControllerPrivateWinRT::abortConnection, worker,
            &QWinRTLowEnergyConnectionHandler::handleDeviceDisconnectRequest);
    connect(thread, &QThread::started, worker, &QWinRTLowEnergyConnectionHandler::connectToDevice);
    connect(thread, &QThread::finished, worker, &QObject::deleteLater);
    connect(worker, &QObject::destroyed, thread, &QObject::deleteLater);
    connect(worker, &QWinRTLowEnergyConnectionHandler::errorOccurred, this,
            [this](const QString &msg) { handleConnectionError(msg.toUtf8().constData()); });
    connect(worker, &QWinRTLowEnergyConnectionHandler::deviceConnected, this,
            [this](ComPtr<IBluetoothLEDevice> device, ComPtr<IGattSession> session) {
                if (!device || !session) {
                    handleConnectionError("Failed to get device or gatt service");
                    return;
                }
                mDevice = device;
                mGattSession = session;
 
                if (!registerForStatusChanges() || !registerForMtuChanges()) {
                    handleConnectionError("Failed to register for changes");
                    return;
                }
 
                Q_Q(QLowEnergyController);
                setState(QLowEnergyController::ConnectedState);
                emit q->connected();
            });
    thread->start();
}
 
void QLowEnergyControllerPrivateWinRT::disconnectFromDevice()
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
    Q_Q(QLowEnergyController);
    setState(QLowEnergyController::ClosingState);
    emit abortConnection();
    unregisterFromValueChanges();
    unregisterFromStatusChanges();
    unregisterFromMtuChanges();
    clearAllServices();
    mGattSession = nullptr;
    mDevice = nullptr;
    setState(QLowEnergyController::UnconnectedState);
    emit q->disconnected();
}
 
HRESULT QLowEnergyControllerPrivateWinRT::getNativeService(const QBluetoothUuid &serviceUuid,
                                                           NativeServiceCallback callback)
{
    if (m_openedServices.contains(serviceUuid)) {
        callback(m_openedServices.value(serviceUuid));
        return S_OK;
    }
 
    ComPtr<IBluetoothLEDevice3> device3;
    HRESULT hr = mDevice.As(&device3);
    RETURN_IF_FAILED("Could not convert to IBluetoothDevice3", return hr);
 
    ComPtr<IAsyncOperation<GattDeviceServicesResult *>> servicesResultOperation;
    hr = device3->GetGattServicesForUuidAsync(serviceUuid, &servicesResultOperation);
    RETURN_IF_FAILED("Could not start async services request", return hr);
 
    QPointer<QLowEnergyControllerPrivateWinRT> thisPtr(this);
    hr = servicesResultOperation->put_Completed(
            Callback<IAsyncOperationCompletedHandler<
                GenericAttributeProfile::GattDeviceServicesResult *>>(
                    [thisPtr, callback, &serviceUuid](
                        IAsyncOperation<GattDeviceServicesResult *> *op, AsyncStatus status)
    {
        if (thisPtr) {
            if (status != AsyncStatus::Completed) {
                qCDebug(QT_BT_WINDOWS) << "Failed to get result of async service request";
                return S_OK;
            }
            ComPtr<IGattDeviceServicesResult> result;
            ComPtr<IVectorView<GattDeviceService *>> deviceServices;
            HRESULT hr = op->GetResults(&result);
            RETURN_IF_FAILED("Failed to get result of async service request", return hr);
 
            ComPtr<IVectorView<GattDeviceService *>> services;
            hr = result->get_Services(&services);
            RETURN_IF_FAILED("Failed to extract services from the result", return hr);
 
            uint servicesCount = 0;
            hr = services->get_Size(&servicesCount);
            RETURN_IF_FAILED("Failed to extract services count", return hr);
 
            if (servicesCount > 0) {
                if (servicesCount > 1) {
                    qWarning() << "getNativeService: more than one service detected for UUID"
                               << serviceUuid << "The first service will be used.";
                }
                ComPtr<IGattDeviceService> service;
                hr = services->GetAt(0, &service);
                if (FAILED(hr)) {
                    qCDebug(QT_BT_WINDOWS) << "Could not obtain native service for Uuid"
                                           << serviceUuid;
                }
                if (service) {
                    thisPtr->m_openedServices[serviceUuid] = service;
                    callback(service); // Use the service in a custom callback
                }
            } else {
                qCWarning(QT_BT_WINDOWS) << "No services found for Uuid" << serviceUuid;
            }
        } else {
            qCWarning(QT_BT_WINDOWS) << "LE controller was removed while getting native service";
        }
        return S_OK;
    }).Get());
 
    return hr;
}
 
HRESULT QLowEnergyControllerPrivateWinRT::getNativeCharacteristic(
        const QBluetoothUuid &serviceUuid, const QBluetoothUuid &charUuid,
        NativeCharacteristicCallback callback)
{
    QPointer<QLowEnergyControllerPrivateWinRT> thisPtr(this);
    auto serviceCallback = [thisPtr, callback, charUuid](ComPtr<IGattDeviceService> service) {
        ComPtr<IGattDeviceService3> service3;
        HRESULT hr = service.As(&service3);
        RETURN_IF_FAILED("Could not cast service to service3", return);
 
        ComPtr<IAsyncOperation<GattCharacteristicsResult *>> characteristicRequestOp;
        hr = service3->GetCharacteristicsForUuidAsync(charUuid, &characteristicRequestOp);
 
        hr = characteristicRequestOp->put_Completed(
                    Callback<IAsyncOperationCompletedHandler<GattCharacteristicsResult *>>(
                        [thisPtr, callback](
                            IAsyncOperation<GattCharacteristicsResult *> *op, AsyncStatus status)
        {
            if (thisPtr) {
                if (status != AsyncStatus::Completed) {
                    qCDebug(QT_BT_WINDOWS) << "Failed to get result of async characteristic "
                                              "operation";
                    return S_OK;
                }
                ComPtr<IGattCharacteristicsResult> result;
                HRESULT hr = op->GetResults(&result);
                RETURN_IF_FAILED("Failed to get result of async characteristic operation",
                                 return hr);
                GattCommunicationStatus status;
                hr = result->get_Status(&status);
                if (FAILED(hr) || status != GattCommunicationStatus_Success) {
                    qErrnoWarning(hr, "Native characteristic operation failed.");
                    return S_OK;
                }
                ComPtr<IVectorView<GattCharacteristic *>> characteristics;
                hr = result->get_Characteristics(&characteristics);
                RETURN_IF_FAILED("Could not obtain characteristic list.", return S_OK);
                uint size;
                hr = characteristics->get_Size(&size);
                RETURN_IF_FAILED("Could not obtain characteristic list's size.", return S_OK);
                if (size != 1)
                    qErrnoWarning("More than 1 characteristic found.");
                ComPtr<IGattCharacteristic> characteristic;
                hr = characteristics->GetAt(0, &characteristic);
                RETURN_IF_FAILED("Could not obtain first characteristic for service", return S_OK);
                if (characteristic)
                    callback(characteristic); // use the characteristic in a custom callback
            }
            return S_OK;
        }).Get());
    };
 
    HRESULT hr = getNativeService(serviceUuid, serviceCallback);
    if (FAILED(hr))
        qCDebug(QT_BT_WINDOWS) << "Failed to get native service for" << serviceUuid;
 
    return hr;
}
 
void QLowEnergyControllerPrivateWinRT::registerForValueChanges(const QBluetoothUuid &serviceUuid,
                                                                  const QBluetoothUuid &charUuid)
{
    qCDebug(QT_BT_WINDOWS) << "Registering characteristic" << charUuid << "in service"
                         << serviceUuid << "for value changes";
    for (const ValueChangedEntry &entry : std::as_const(mValueChangedTokens)) {
        GUID guuid;
        HRESULT hr;
        hr = entry.characteristic->get_Uuid(&guuid);
        WARN_AND_CONTINUE_IF_FAILED(hr, "Could not obtain characteristic's Uuid")
        if (QBluetoothUuid(guuid) == charUuid)
            return;
    }
 
    auto callback = [this, charUuid, serviceUuid](ComPtr<IGattCharacteristic> characteristic) {
        EventRegistrationToken token;
        HRESULT hr;
        hr = characteristic->add_ValueChanged(
                    Callback<ValueChangedHandler>(
                        this, &QLowEnergyControllerPrivateWinRT::onValueChange).Get(),
                    &token);
        RETURN_IF_FAILED("Could not register characteristic for value changes", return)
        mValueChangedTokens.append(ValueChangedEntry(characteristic, token));
        qCDebug(QT_BT_WINDOWS) << "Characteristic" << charUuid << "in service"
                               << serviceUuid << "registered for value changes";
    };
 
    HRESULT hr = getNativeCharacteristic(serviceUuid, charUuid, callback);
    if (FAILED(hr)) {
        qCDebug(QT_BT_WINDOWS).nospace() << "Could not obtain native characteristic "
                                         << charUuid << " from service " << serviceUuid
                                         << ". Qt will not be able to signal"
                                         << " changes for this characteristic.";
    }
}
 
void QLowEnergyControllerPrivateWinRT::unregisterFromValueChanges()
{
    qCDebug(QT_BT_WINDOWS) << "Unregistering " << mValueChangedTokens.size() << " value change tokens";
    HRESULT hr;
    for (const ValueChangedEntry &entry : std::as_const(mValueChangedTokens)) {
        if (!entry.characteristic) {
            qCWarning(QT_BT_WINDOWS) << "Unregistering from value changes for characteristic failed."
                                   << "Characteristic has been deleted";
            continue;
        }
        hr = entry.characteristic->remove_ValueChanged(entry.token);
        if (FAILED(hr))
            qCWarning(QT_BT_WINDOWS) << "Unregistering from value changes for characteristic failed.";
    }
    mValueChangedTokens.clear();
}
 
HRESULT QLowEnergyControllerPrivateWinRT::onValueChange(IGattCharacteristic *characteristic, IGattValueChangedEventArgs *args)
{
    HRESULT hr;
    quint16 handle;
    hr = characteristic->get_AttributeHandle(&handle);
    RETURN_IF_FAILED("Could not obtain characteristic's handle", return S_OK)
    ComPtr<IBuffer> buffer;
    hr = args->get_CharacteristicValue(&buffer);
    RETURN_IF_FAILED("Could not obtain characteristic's value", return S_OK)
    emit characteristicChanged(handle, byteArrayFromBuffer(buffer));
    return S_OK;
}
HRESULT QLowEnergyControllerPrivateWinRT::onMtuChange(IGattSession *session, IInspectable *args)
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
    if (session != mGattSession.Get()) {
        qCWarning(QT_BT_WINDOWS) << "Got MTU changed event for wrong or outdated GattSession.";
        return S_OK;
    }
 
    Q_Q(QLowEnergyController);
    emit q->mtuChanged(mtu());
    return S_OK;
}
 
bool QLowEnergyControllerPrivateWinRT::registerForStatusChanges()
{
    if (!mDevice)
        return false;
 
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
 
    HRESULT hr;
    hr = mDevice->add_ConnectionStatusChanged(
        Callback<StatusHandler>(this, &QLowEnergyControllerPrivateWinRT::onStatusChange).Get(),
                                &mStatusChangedToken);
    RETURN_IF_FAILED("Could not add status callback", return false)
    return true;
}
 
void QLowEnergyControllerPrivateWinRT::unregisterFromStatusChanges()
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
    if (mDevice && mStatusChangedToken.value) {
        mDevice->remove_ConnectionStatusChanged(mStatusChangedToken);
        mStatusChangedToken.value = 0;
    }
}
 
bool QLowEnergyControllerPrivateWinRT::registerForMtuChanges()
{
    if (!mDevice || !mGattSession)
        return false;
 
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
 
    HRESULT hr;
    hr = mGattSession->add_MaxPduSizeChanged(
            Callback<MtuHandler>(this, &QLowEnergyControllerPrivateWinRT::onMtuChange).Get(),
            &mMtuChangedToken);
    RETURN_IF_FAILED("Could not add MTU callback", return false)
    return true;
}
 
void QLowEnergyControllerPrivateWinRT::unregisterFromMtuChanges()
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__;
    if (mDevice && mGattSession && mMtuChangedToken.value) {
        mGattSession->remove_MaxPduSizeChanged(mMtuChangedToken);
        mMtuChangedToken.value = 0;
    }
}
 
HRESULT QLowEnergyControllerPrivateWinRT::onStatusChange(IBluetoothLEDevice *dev, IInspectable *)
{
    Q_Q(QLowEnergyController);
    BluetoothConnectionStatus status;
    HRESULT hr;
    hr = dev->get_ConnectionStatus(&status);
    RETURN_IF_FAILED("Could not obtain connection status", return S_OK)
    if (state == QLowEnergyController::ConnectingState
        && status == BluetoothConnectionStatus::BluetoothConnectionStatus_Connected) {
        setState(QLowEnergyController::ConnectedState);
        emit q->connected();
    } else if (state != QLowEnergyController::UnconnectedState
        && status == BluetoothConnectionStatus::BluetoothConnectionStatus_Disconnected) {
        invalidateServices();
        unregisterFromValueChanges();
        unregisterFromStatusChanges();
        unregisterFromMtuChanges();
        mGattSession = nullptr;
        mDevice = nullptr;
        setError(QLowEnergyController::RemoteHostClosedError);
        setState(QLowEnergyController::UnconnectedState);
        emit q->disconnected();
    }
    return S_OK;
}
 
void QLowEnergyControllerPrivateWinRT::obtainIncludedServices(
        QSharedPointer<QLowEnergyServicePrivate> servicePointer,
        ComPtr<IGattDeviceService> service)
{
    Q_Q(QLowEnergyController);
    ComPtr<IGattDeviceService3> service3;
    HRESULT hr = service.As(&service3);
    RETURN_IF_FAILED("Could not cast service", return);
    ComPtr<IAsyncOperation<GattDeviceServicesResult *>> op;
    hr = service3->GetIncludedServicesAsync(&op);
    // Some devices return ERROR_ACCESS_DISABLED_BY_POLICY
    RETURN_IF_FAILED("Could not obtain included services", return);
    ComPtr<IGattDeviceServicesResult> result;
    hr = QWinRTFunctions::await(op, result.GetAddressOf(), QWinRTFunctions::ProcessMainThreadEvents, 5000);
    RETURN_IF_FAILED("Could not await service operation", return);
    // The device can be disconnected by the time we return from await()
    if (state != QLowEnergyController::DiscoveringState)
        return;
    GattCommunicationStatus status;
    hr = result->get_Status(&status);
    if (FAILED(hr) || status != GattCommunicationStatus_Success) {
        qErrnoWarning("Could not obtain list of included services");
        return;
    }
    ComPtr<IVectorView<GattDeviceService *>> includedServices;
    hr = result->get_Services(&includedServices);
    RETURN_IF_FAILED("Could not obtain service list", return);
 
    uint count;
    hr = includedServices->get_Size(&count);
    RETURN_IF_FAILED("Could not obtain service list's size", return);
    for (uint i = 0; i < count; ++i) {
        ComPtr<IGattDeviceService> includedService;
        hr = includedServices->GetAt(i, &includedService);
        WARN_AND_CONTINUE_IF_FAILED(hr, "Could not obtain service from list");
        GUID guuid;
        hr = includedService->get_Uuid(&guuid);
        WARN_AND_CONTINUE_IF_FAILED(hr, "Could not obtain included service's Uuid");
        const QBluetoothUuid includedUuid(guuid);
        QSharedPointer<QLowEnergyServicePrivate> includedPointer;
        qCDebug(QT_BT_WINDOWS_SERVICE_THREAD) << __FUNCTION__
                                            << "Changing service pointer from thread"
                                            << QThread::currentThread();
        if (serviceList.contains(includedUuid)) {
            includedPointer = serviceList.value(includedUuid);
        } else {
            QLowEnergyServicePrivate *priv = new QLowEnergyServicePrivate();
            priv->uuid = includedUuid;
            priv->setController(this);
 
            includedPointer = QSharedPointer<QLowEnergyServicePrivate>(priv);
            serviceList.insert(includedUuid, includedPointer);
        }
        includedPointer->type |= QLowEnergyService::IncludedService;
        servicePointer->includedServices.append(includedUuid);
 
        obtainIncludedServices(includedPointer, includedService);
 
        emit q->serviceDiscovered(includedUuid);
    }
}
 
HRESULT QLowEnergyControllerPrivateWinRT::onServiceDiscoveryFinished(ABI::Windows::Foundation::IAsyncOperation<GattDeviceServicesResult *> *op, AsyncStatus status)
{
    // Check if the device is in the proper state, because it can already be
    // disconnected when the callback arrives.
    // Also the callback can theoretically come when the connection is
    // reestablisheed again (for example, if the user quickly clicks
    // "Disconnect" and then "Connect" again in some UI). But we can probably
    // omit such details, as we are connecting to the same device anyway.
    if (state != QLowEnergyController::DiscoveringState)
        return S_OK;
 
    Q_Q(QLowEnergyController);
    if (status != AsyncStatus::Completed) {
        qCDebug(QT_BT_WINDOWS) << "Could not obtain services";
        return S_OK;
    }
    ComPtr<IGattDeviceServicesResult> result;
    ComPtr<IVectorView<GattDeviceService *>> deviceServices;
    HRESULT hr = op->GetResults(&result);
    CHECK_FOR_DEVICE_CONNECTION_ERROR(hr, "Could not obtain service discovery result",
                                      return S_OK);
    GattCommunicationStatus commStatus;
    hr = result->get_Status(&commStatus);
    CHECK_FOR_DEVICE_CONNECTION_ERROR(hr, "Could not obtain service discovery status",
                                      return S_OK);
    if (commStatus != GattCommunicationStatus_Success)
        return S_OK;
 
    hr = result->get_Services(&deviceServices);
    CHECK_FOR_DEVICE_CONNECTION_ERROR(hr, "Could not obtain service list",
                                      return S_OK);
 
    uint serviceCount;
    hr = deviceServices->get_Size(&serviceCount);
    CHECK_FOR_DEVICE_CONNECTION_ERROR(hr, "Could not obtain service list size",
                                      return S_OK);
    for (uint i = 0; i < serviceCount; ++i) {
        ComPtr<IGattDeviceService> deviceService;
        hr = deviceServices->GetAt(i, &deviceService);
        WARN_AND_CONTINUE_IF_FAILED(hr, "Could not obtain service");
        GUID guuid;
        hr = deviceService->get_Uuid(&guuid);
        WARN_AND_CONTINUE_IF_FAILED(hr, "Could not obtain service's Uuid");
        const QBluetoothUuid service(guuid);
        m_openedServices[service] = deviceService;
 
        qCDebug(QT_BT_WINDOWS_SERVICE_THREAD) << __FUNCTION__
                                            << "Changing service pointer from thread"
                                            << QThread::currentThread();
        QSharedPointer<QLowEnergyServicePrivate> pointer;
        if (serviceList.contains(service)) {
            pointer = serviceList.value(service);
        } else {
            QLowEnergyServicePrivate *priv = new QLowEnergyServicePrivate();
            priv->uuid = service;
            priv->setController(this);
 
            pointer = QSharedPointer<QLowEnergyServicePrivate>(priv);
            serviceList.insert(service, pointer);
        }
        pointer->type |= QLowEnergyService::PrimaryService;
 
        obtainIncludedServices(pointer, deviceService);
        // The obtainIncludedServices method calls await(), so the device can be
        // disconnected by the time we return from it. TODO - rewrite in an
        // async way!
        if (state != QLowEnergyController::DiscoveringState) {
            emit q->discoveryFinished(); // Probably not needed when the device
                                         // is already disconnected?
            return S_OK;
        }
 
        emit q->serviceDiscovered(service);
    }
 
    setState(QLowEnergyController::DiscoveredState);
    emit q->discoveryFinished();
 
    return S_OK;
}
 
void QLowEnergyControllerPrivateWinRT::clearAllServices()
{
    // These services will be closed in the respective
    // QWinRTLowEnergyServiceHandler workers (in background threads).
    for (auto &uuid : m_requestDetailsServiceUuids)
        m_openedServices.remove(uuid);
    m_requestDetailsServiceUuids.clear();
 
    for (auto service : m_openedServices) {
        closeDeviceService(service);
    }
    m_openedServices.clear();
}
 
void QLowEnergyControllerPrivateWinRT::closeAndRemoveService(const QBluetoothUuid &uuid)
{
    auto service = m_openedServices.take(uuid);
    if (service)
        closeDeviceService(service);
}
 
void QLowEnergyControllerPrivateWinRT::discoverServices()
{
    qCDebug(QT_BT_WINDOWS) << "Service discovery initiated";
    // clear the previous services cache, as we request the services again
    clearAllServices();
    ComPtr<IBluetoothLEDevice3> device3;
    HRESULT hr = mDevice.As(&device3);
    CHECK_FOR_DEVICE_CONNECTION_ERROR(hr, "Could not cast device", return);
    ComPtr<IAsyncOperation<GenericAttributeProfile::GattDeviceServicesResult *>> asyncResult;
    hr = device3->GetGattServicesAsync(&asyncResult);
    CHECK_FOR_DEVICE_CONNECTION_ERROR(hr, "Could not obtain services", return);
    hr = asyncResult->put_Completed(
        Callback<IAsyncOperationCompletedHandler<GenericAttributeProfile::GattDeviceServicesResult *>>(
                this, &QLowEnergyControllerPrivateWinRT::onServiceDiscoveryFinished).Get());
    CHECK_FOR_DEVICE_CONNECTION_ERROR(hr, "Could not register services discovery callback",
                                      return);
}
 
void QLowEnergyControllerPrivateWinRT::discoverServiceDetails(
        const QBluetoothUuid &service, QLowEnergyService::DiscoveryMode mode)
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__ << service;
    if (!serviceList.contains(service)) {
        qCWarning(QT_BT_WINDOWS) << "Discovery done of unknown service:"
            << service.toString();
        return;
    }
 
    // clear the cache to rediscover service details
    closeAndRemoveService(service);
 
    auto serviceCallback = [service, mode, this](ComPtr<IGattDeviceService> deviceService) {
        discoverServiceDetailsHelper(service, mode, deviceService);
    };
 
    HRESULT hr = getNativeService(service, serviceCallback);
    if (FAILED(hr))
        qCDebug(QT_BT_WINDOWS) << "Could not obtain native service for uuid " << service;
}
 
void QLowEnergyControllerPrivateWinRT::discoverServiceDetailsHelper(
        const QBluetoothUuid &service, QLowEnergyService::DiscoveryMode mode,
        GattDeviceServiceComPtr deviceService)
{
    auto reactOnDiscoveryError = [](QSharedPointer<QLowEnergyServicePrivate> service,
                                    const QString &msg)
    {
        qCDebug(QT_BT_WINDOWS) << msg;
        service->setError(QLowEnergyService::UnknownError);
        service->setState(QLowEnergyService::RemoteService);
    };
    //update service data
    QSharedPointer<QLowEnergyServicePrivate> pointer = serviceList.value(service);
    if (!pointer) {
        qCDebug(QT_BT_WINDOWS) << "Device was disconnected while doing service discovery";
        return;
    }
    qCDebug(QT_BT_WINDOWS_SERVICE_THREAD) << __FUNCTION__ << "Changing service pointer from thread"
                                          << QThread::currentThread();
    pointer->setState(QLowEnergyService::RemoteServiceDiscovering);
    ComPtr<IGattDeviceService3> deviceService3;
    HRESULT hr = deviceService.As(&deviceService3);
    if (FAILED(hr)) {
        reactOnDiscoveryError(pointer, QStringLiteral("Could not cast service: %1").arg(hr));
        return;
    }
    ComPtr<IAsyncOperation<GattDeviceServicesResult *>> op;
    hr = deviceService3->GetIncludedServicesAsync(&op);
    if (FAILED(hr)) {
        reactOnDiscoveryError(pointer,
                              QStringLiteral("Could not obtain included service list: %1").arg(hr));
        return;
    }
    ComPtr<IGattDeviceServicesResult> result;
    hr = QWinRTFunctions::await(op, result.GetAddressOf());
    if (FAILED(hr)) {
        reactOnDiscoveryError(pointer,
                              QStringLiteral("Could not await service operation: %1").arg(hr));
        return;
    }
    GattCommunicationStatus status;
    hr = result->get_Status(&status);
    if (FAILED(hr) || status != GattCommunicationStatus_Success) {
        reactOnDiscoveryError(pointer,
                              QStringLiteral("Obtaining list of included services failed: %1").
                              arg(hr));
        return;
    }
    ComPtr<IVectorView<GattDeviceService *>> deviceServices;
    hr = result->get_Services(&deviceServices);
    if (FAILED(hr)) {
        reactOnDiscoveryError(pointer,
                              QStringLiteral("Could not obtain service list from result: %1").
                              arg(hr));
        return;
    }
    uint serviceCount;
    hr = deviceServices->get_Size(&serviceCount);
    if (FAILED(hr)) {
        reactOnDiscoveryError(pointer,
                              QStringLiteral("Could not obtain included service list's size: %1").
                              arg(hr));
        return;
    }
    for (uint i = 0; i < serviceCount; ++i) {
        ComPtr<IGattDeviceService> includedService;
        hr = deviceServices->GetAt(i, &includedService);
        WARN_AND_CONTINUE_IF_FAILED(hr, "Could not obtain service from list")
        GUID guuid;
        hr = includedService->get_Uuid(&guuid);
        WARN_AND_CONTINUE_IF_FAILED(hr, "Could not obtain service Uuid")
 
        const QBluetoothUuid service(guuid);
        if (service.isNull()) {
            qCDebug(QT_BT_WINDOWS) << "Could not find service";
            continue;
        }
 
        pointer->includedServices.append(service);
 
        // update the type of the included service
        QSharedPointer<QLowEnergyServicePrivate> otherService = serviceList.value(service);
        if (!otherService.isNull())
            otherService->type |= QLowEnergyService::IncludedService;
    }
 
    QWinRTLowEnergyServiceHandler *worker =
            new QWinRTLowEnergyServiceHandler(service, deviceService3, mode);
    m_requestDetailsServiceUuids.insert(service);
    QThread *thread = new QThread;
    worker->moveToThread(thread);
    connect(thread, &QThread::started, worker, &QWinRTLowEnergyServiceHandler::obtainCharList);
    connect(thread, &QThread::finished, worker, &QObject::deleteLater);
    connect(worker, &QObject::destroyed, thread, &QObject::deleteLater);
    connect(this, &QLowEnergyControllerPrivateWinRT::abortConnection,
            worker, &QWinRTLowEnergyServiceHandler::setAbortRequested);
    connect(worker, &QWinRTLowEnergyServiceHandler::errorOccured,
            this, &QLowEnergyControllerPrivateWinRT::handleServiceHandlerError);
    connect(worker, &QWinRTLowEnergyServiceHandler::charListObtained, this,
            [this](const QBluetoothUuid &service, QHash<QLowEnergyHandle,
            QLowEnergyServicePrivate::CharData> charList, QList<QBluetoothUuid> indicateChars,
            QLowEnergyHandle startHandle, QLowEnergyHandle endHandle) {
        if (!serviceList.contains(service)) {
            qCWarning(QT_BT_WINDOWS)
                    << "Discovery complete for unknown service:" << service.toString();
            return;
        }
        m_requestDetailsServiceUuids.remove(service);
 
        QSharedPointer<QLowEnergyServicePrivate> pointer = serviceList.value(service);
        pointer->startHandle = startHandle;
        pointer->endHandle = endHandle;
        pointer->characteristicList = charList;
 
        for (const QBluetoothUuid &indicateChar : std::as_const(indicateChars))
            registerForValueChanges(service, indicateChar);
 
        pointer->setState(QLowEnergyService::RemoteServiceDiscovered);
    });
    thread->start();
}
 
void QLowEnergyControllerPrivateWinRT::startAdvertising(
        const QLowEnergyAdvertisingParameters &,
        const QLowEnergyAdvertisingData &,
        const QLowEnergyAdvertisingData &)
{
    setError(QLowEnergyController::AdvertisingError);
    Q_UNIMPLEMENTED();
}
 
void QLowEnergyControllerPrivateWinRT::stopAdvertising()
{
    Q_UNIMPLEMENTED();
}
 
void QLowEnergyControllerPrivateWinRT::requestConnectionUpdate(const QLowEnergyConnectionParameters &)
{
    Q_UNIMPLEMENTED();
}
 
void QLowEnergyControllerPrivateWinRT::readCharacteristic(
        const QSharedPointer<QLowEnergyServicePrivate> service,
        const QLowEnergyHandle charHandle)
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__ << service << charHandle;
    qCDebug(QT_BT_WINDOWS_SERVICE_THREAD) << __FUNCTION__ << "Changing service pointer from thread"
                                        << QThread::currentThread();
    Q_ASSERT(!service.isNull());
    if (role == QLowEnergyController::PeripheralRole) {
        service->setError(QLowEnergyService::CharacteristicReadError);
        Q_UNIMPLEMENTED();
        return;
    }
 
    if (!service->characteristicList.contains(charHandle)) {
        qCDebug(QT_BT_WINDOWS) << charHandle << "could not be found in service" << service->uuid;
        service->setError(QLowEnergyService::CharacteristicReadError);
        return;
    }
 
    const auto charData = service->characteristicList.value(charHandle);
    if (!(charData.properties & QLowEnergyCharacteristic::Read))
        qCDebug(QT_BT_WINDOWS) << "Read flag is not set for characteristic" << charData.uuid;
 
    auto characteristicCallback = [charHandle, service, this](
            ComPtr<IGattCharacteristic> characteristic) {
        readCharacteristicHelper(service, charHandle, characteristic);
    };
 
    HRESULT hr = getNativeCharacteristic(service->uuid, charData.uuid, characteristicCallback);
    if (FAILED(hr)) {
        qCDebug(QT_BT_WINDOWS) << "Could not obtain native characteristic" << charData.uuid
                               << "from service" << service->uuid;
        service->setError(QLowEnergyService::CharacteristicReadError);
    }
}
 
void QLowEnergyControllerPrivateWinRT::readCharacteristicHelper(
        const QSharedPointer<QLowEnergyServicePrivate> service,
        const QLowEnergyHandle charHandle,
        GattCharacteristicComPtr characteristic)
{
    ComPtr<IAsyncOperation<GattReadResult *>> readOp;
    HRESULT hr = characteristic->ReadValueWithCacheModeAsync(BluetoothCacheMode_Uncached, &readOp);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not read characteristic",
                                   service, QLowEnergyService::CharacteristicReadError, return)
    auto readCompletedLambda = [charHandle, service]
            (IAsyncOperation<GattReadResult*> *op, AsyncStatus status)
    {
        if (status == AsyncStatus::Canceled || status == AsyncStatus::Error) {
            qCDebug(QT_BT_WINDOWS) << "Characteristic" << charHandle << "read operation failed.";
            service->setError(QLowEnergyService::CharacteristicReadError);
            return S_OK;
        }
        ComPtr<IGattReadResult> characteristicValue;
        HRESULT hr;
        hr = op->GetResults(&characteristicValue);
        CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain result for characteristic", service,
                                       QLowEnergyService::CharacteristicReadError, return S_OK)
 
        const QByteArray value = byteArrayFromGattResult(characteristicValue);
        auto charData = service->characteristicList.value(charHandle);
        charData.value = value;
        service->characteristicList.insert(charHandle, charData);
        emit service->characteristicRead(QLowEnergyCharacteristic(service, charHandle), value);
        return S_OK;
    };
    hr = readOp->put_Completed(Callback<IAsyncOperationCompletedHandler<GattReadResult *>>(
                                   readCompletedLambda).Get());
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not register characteristic read callback",
                                   service, QLowEnergyService::CharacteristicReadError, return)
}
 
void QLowEnergyControllerPrivateWinRT::readDescriptor(
        const QSharedPointer<QLowEnergyServicePrivate> service,
        const QLowEnergyHandle charHandle,
        const QLowEnergyHandle descHandle)
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__ << service << charHandle << descHandle;
    qCDebug(QT_BT_WINDOWS_SERVICE_THREAD) << __FUNCTION__ << "Changing service pointer from thread"
                                        << QThread::currentThread();
    Q_ASSERT(!service.isNull());
    if (role == QLowEnergyController::PeripheralRole) {
        service->setError(QLowEnergyService::DescriptorReadError);
        Q_UNIMPLEMENTED();
        return;
    }
 
    if (!service->characteristicList.contains(charHandle)) {
        qCDebug(QT_BT_WINDOWS) << "Descriptor" << descHandle << "in characteristic" << charHandle
                             << "cannot be found in service" << service->uuid;
        service->setError(QLowEnergyService::DescriptorReadError);
        return;
    }
 
    const auto charData = service->characteristicList.value(charHandle);
 
    auto characteristicCallback = [charHandle, descHandle, service, this](
            ComPtr<IGattCharacteristic> characteristic) {
        readDescriptorHelper(service, charHandle, descHandle, characteristic);
    };
 
    HRESULT hr = getNativeCharacteristic(service->uuid, charData.uuid, characteristicCallback);
    if (FAILED(hr)) {
        qCDebug(QT_BT_WINDOWS) << "Could not obtain native characteristic" << charData.uuid
                               << "from service" << service->uuid;
        service->setError(QLowEnergyService::DescriptorReadError);
    }
}
 
void QLowEnergyControllerPrivateWinRT::readDescriptorHelper(
        const QSharedPointer<QLowEnergyServicePrivate> service,
        const QLowEnergyHandle charHandle,
        const QLowEnergyHandle descHandle,
        GattCharacteristicComPtr characteristic)
{
    // Get native descriptor
    const auto charData = service->characteristicList.value(charHandle);
    if (!charData.descriptorList.contains(descHandle)) {
        qCDebug(QT_BT_WINDOWS) << "Descriptor" << descHandle << "cannot be found in characteristic"
                               << charHandle;
    }
    const auto descData = charData.descriptorList.value(descHandle);
    const QBluetoothUuid descUuid = descData.uuid;
    if (descUuid ==
            QBluetoothUuid(QBluetoothUuid::DescriptorType::ClientCharacteristicConfiguration)) {
        ComPtr<IAsyncOperation<ClientCharConfigDescriptorResult *>> readOp;
        HRESULT hr = characteristic->ReadClientCharacteristicConfigurationDescriptorAsync(&readOp);
        CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not read client characteristic configuration",
                                       service, QLowEnergyService::DescriptorReadError, return)
        auto readCompletedLambda = [charHandle, descHandle, service]
                (IAsyncOperation<ClientCharConfigDescriptorResult *> *op, AsyncStatus status)
        {
            if (status == AsyncStatus::Canceled || status == AsyncStatus::Error) {
                qCDebug(QT_BT_WINDOWS) << "Descriptor" << descHandle << "read operation failed";
                service->setError(QLowEnergyService::DescriptorReadError);
                return S_OK;
            }
            ComPtr<IClientCharConfigDescriptorResult> iValue;
            HRESULT hr;
            hr = op->GetResults(&iValue);
            CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain result for descriptor", service,
                                           QLowEnergyService::DescriptorReadError, return S_OK)
            GattClientCharacteristicConfigurationDescriptorValue value;
            hr = iValue->get_ClientCharacteristicConfigurationDescriptor(&value);
            CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain value for descriptor", service,
                                           QLowEnergyService::DescriptorReadError, return S_OK)
            quint16 result = 0;
            bool correct = false;
            if (value & GattClientCharacteristicConfigurationDescriptorValue_Indicate) {
                result |= QLowEnergyCharacteristic::Indicate;
                correct = true;
            }
            if (value & GattClientCharacteristicConfigurationDescriptorValue_Notify) {
                result |= QLowEnergyCharacteristic::Notify;
                correct = true;
            }
            if (value == GattClientCharacteristicConfigurationDescriptorValue_None)
                correct = true;
            if (!correct) {
                qCDebug(QT_BT_WINDOWS) << "Descriptor" << descHandle
                                       << "read operation failed. Obtained unexpected value.";
                service->setError(QLowEnergyService::DescriptorReadError);
                return S_OK;
            }
            QLowEnergyServicePrivate::DescData descData;
            descData.uuid = QBluetoothUuid::DescriptorType::ClientCharacteristicConfiguration;
            descData.value = QByteArray(2, Qt::Uninitialized);
            qToLittleEndian(result, descData.value.data());
            service->characteristicList[charHandle].descriptorList[descHandle] = descData;
            emit service->descriptorRead(QLowEnergyDescriptor(service, charHandle, descHandle),
                                         descData.value);
            return S_OK;
        };
        hr = readOp->put_Completed(
                    Callback<IAsyncOperationCompletedHandler<ClientCharConfigDescriptorResult *>>(
                        readCompletedLambda).Get());
        CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not register descriptor read callback",
                                       service, QLowEnergyService::DescriptorReadError, return)
        return;
    }
 
    ComPtr<IGattCharacteristic3> characteristic3;
    HRESULT hr = characteristic.As(&characteristic3);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not cast characteristic",
                                   service, QLowEnergyService::DescriptorReadError, return)
    ComPtr<IAsyncOperation<GattDescriptorsResult *>> op;
    hr = characteristic3->GetDescriptorsForUuidAsync(descData.uuid, &op);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain descriptor for uuid",
                                   service, QLowEnergyService::DescriptorReadError, return)
    ComPtr<IGattDescriptorsResult> result;
    hr = QWinRTFunctions::await(op, result.GetAddressOf(),
                                QWinRTFunctions::ProcessMainThreadEvents, 5000);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not await descritpor read result",
                                   service, QLowEnergyService::DescriptorReadError, return)
 
    GattCommunicationStatus commStatus;
    hr = result->get_Status(&commStatus);
    if (FAILED(hr) || commStatus != GattCommunicationStatus_Success) {
        qErrnoWarning("Could not obtain list of descriptors");
        service->setError(QLowEnergyService::DescriptorReadError);
        return;
    }
 
    ComPtr<IVectorView<GattDescriptor *>> descriptors;
    hr = result->get_Descriptors(&descriptors);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain descriptor list",
                                   service, QLowEnergyService::DescriptorReadError, return)
    uint size;
    hr = descriptors->get_Size(&size);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not await descritpor list's size",
                                   service, QLowEnergyService::DescriptorReadError, return)
    if (size == 0) {
        qCWarning(QT_BT_WINDOWS) << "No descriptor with uuid" << descData.uuid << "was found.";
        service->setError(QLowEnergyService::DescriptorReadError);
        return;
    } else if (size > 1) {
        qCWarning(QT_BT_WINDOWS) << "There is more than 1 descriptor with uuid" << descData.uuid;
    }
 
    ComPtr<IGattDescriptor> descriptor;
    hr = descriptors->GetAt(0, &descriptor);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain descritpor from list",
                                   service, QLowEnergyService::DescriptorReadError, return)
    ComPtr<IAsyncOperation<GattReadResult*>> readOp;
    hr = descriptor->ReadValueWithCacheModeAsync(BluetoothCacheMode_Uncached, &readOp);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not read descriptor value",
                                   service, QLowEnergyService::DescriptorReadError, return)
    auto readCompletedLambda = [charHandle, descHandle, descUuid, service]
            (IAsyncOperation<GattReadResult*> *op, AsyncStatus status)
    {
        if (status == AsyncStatus::Canceled || status == AsyncStatus::Error) {
            qCDebug(QT_BT_WINDOWS) << "Descriptor" << descHandle << "read operation failed";
            service->setError(QLowEnergyService::DescriptorReadError);
            return S_OK;
        }
        ComPtr<IGattReadResult> descriptorValue;
        HRESULT hr;
        hr = op->GetResults(&descriptorValue);
        if (FAILED(hr)) {
            qCDebug(QT_BT_WINDOWS) << "Could not obtain result for descriptor" << descHandle;
            service->setError(QLowEnergyService::DescriptorReadError);
            return S_OK;
        }
        QLowEnergyServicePrivate::DescData descData;
        descData.uuid = descUuid;
        if (descData.uuid == QBluetoothUuid::DescriptorType::CharacteristicUserDescription)
            descData.value = byteArrayFromGattResult(descriptorValue, true);
        else
            descData.value = byteArrayFromGattResult(descriptorValue);
        service->characteristicList[charHandle].descriptorList[descHandle] = descData;
        emit service->descriptorRead(QLowEnergyDescriptor(service, charHandle, descHandle),
                                     descData.value);
        return S_OK;
    };
    hr = readOp->put_Completed(Callback<IAsyncOperationCompletedHandler<GattReadResult *>>(
                                   readCompletedLambda).Get());
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not register descriptor read callback",
                                   service, QLowEnergyService::DescriptorReadError, return)
}
 
void QLowEnergyControllerPrivateWinRT::writeCharacteristic(
        const QSharedPointer<QLowEnergyServicePrivate> service,
        const QLowEnergyHandle charHandle,
        const QByteArray &newValue,
        QLowEnergyService::WriteMode mode)
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__ << service << charHandle << newValue << mode;
    qCDebug(QT_BT_WINDOWS_SERVICE_THREAD) << __FUNCTION__ << "Changing service pointer from thread"
                                        << QThread::currentThread();
    Q_ASSERT(!service.isNull());
    if (role == QLowEnergyController::PeripheralRole) {
        service->setError(QLowEnergyService::CharacteristicWriteError);
        Q_UNIMPLEMENTED();
        return;
    }
    if (!service->characteristicList.contains(charHandle)) {
        qCDebug(QT_BT_WINDOWS) << "Characteristic" << charHandle << "cannot be found in service"
                             << service->uuid;
        service->setError(QLowEnergyService::CharacteristicWriteError);
        return;
    }
 
    QLowEnergyServicePrivate::CharData charData = service->characteristicList.value(charHandle);
    const bool writeWithResponse = mode == QLowEnergyService::WriteWithResponse;
    if (!(charData.properties & (writeWithResponse ? QLowEnergyCharacteristic::Write
             : QLowEnergyCharacteristic::WriteNoResponse)))
        qCDebug(QT_BT_WINDOWS) << "Write flag is not set for characteristic" << charHandle;
 
    auto characteristicCallback = [charHandle, service, newValue, writeWithResponse, this](
            ComPtr<IGattCharacteristic> characteristic) {
        writeCharacteristicHelper(service, charHandle, newValue, writeWithResponse,
                                  characteristic);
    };
 
    HRESULT hr = getNativeCharacteristic(service->uuid, charData.uuid, characteristicCallback);
    if (FAILED(hr)) {
        qCDebug(QT_BT_WINDOWS) << "Could not obtain native characteristic" << charData.uuid
                               << "from service" << service->uuid;
        service->setError(QLowEnergyService::CharacteristicWriteError);
    }
}
 
void QLowEnergyControllerPrivateWinRT::writeCharacteristicHelper(
        const QSharedPointer<QLowEnergyServicePrivate> service,
        const QLowEnergyHandle charHandle, const QByteArray &newValue,
        bool writeWithResponse, GattCharacteristicComPtr characteristic)
{
    ComPtr<ABI::Windows::Storage::Streams::IBufferFactory> bufferFactory;
    HRESULT hr = GetActivationFactory(
                    HStringReference(RuntimeClass_Windows_Storage_Streams_Buffer).Get(),
                    &bufferFactory);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain buffer factory",
                                   service, QLowEnergyService::CharacteristicWriteError, return)
    ComPtr<ABI::Windows::Storage::Streams::IBuffer> buffer;
    const quint32 length = quint32(newValue.length());
    hr = bufferFactory->Create(length, &buffer);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not create buffer",
                                   service, QLowEnergyService::CharacteristicWriteError, return)
    hr = buffer->put_Length(length);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not set buffer length",
                                   service, QLowEnergyService::CharacteristicWriteError, return)
    ComPtr<Windows::Storage::Streams::IBufferByteAccess> byteAccess;
    hr = buffer.As(&byteAccess);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not cast buffer",
                                   service, QLowEnergyService::CharacteristicWriteError, return)
    byte *bytes;
    hr = byteAccess->Buffer(&bytes);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not set buffer",
                                   service, QLowEnergyService::CharacteristicWriteError, return)
    memcpy(bytes, newValue, length);
    ComPtr<IAsyncOperation<GattCommunicationStatus>> writeOp;
    GattWriteOption option = writeWithResponse ? GattWriteOption_WriteWithResponse
                                               : GattWriteOption_WriteWithoutResponse;
    hr = characteristic->WriteValueWithOptionAsync(buffer.Get(), option, &writeOp);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could write characteristic",
                                   service, QLowEnergyService::CharacteristicWriteError, return)
    const auto charData = service->characteristicList.value(charHandle);
    QPointer<QLowEnergyControllerPrivateWinRT> thisPtr(this);
    auto writeCompletedLambda =
            [charData, charHandle, newValue, service, writeWithResponse, thisPtr]
                (IAsyncOperation<GattCommunicationStatus> *op, AsyncStatus status)
    {
        if (status == AsyncStatus::Canceled || status == AsyncStatus::Error) {
            qCDebug(QT_BT_WINDOWS) << "Characteristic" << charHandle << "write operation failed";
            service->setError(QLowEnergyService::CharacteristicWriteError);
            return S_OK;
        }
        GattCommunicationStatus result;
        HRESULT hr;
        hr = op->GetResults(&result);
        if (hr == E_BLUETOOTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH) {
            qCDebug(QT_BT_WINDOWS) << "Characteristic" << charHandle
                                   << "write operation was tried with invalid value length";
            service->setError(QLowEnergyService::CharacteristicWriteError);
            return S_OK;
        }
        CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain characteristic write result", service,
                                       QLowEnergyService::CharacteristicWriteError, return S_OK)
        if (result != GattCommunicationStatus_Success) {
            qCDebug(QT_BT_WINDOWS) << "Characteristic" << charHandle << "write operation failed";
            service->setError(QLowEnergyService::CharacteristicWriteError);
            return S_OK;
        }
        // only update cache when property is readable. Otherwise it remains
        // empty.
        if (thisPtr && charData.properties & QLowEnergyCharacteristic::Read)
            thisPtr->updateValueOfCharacteristic(charHandle, newValue, false);
        if (writeWithResponse) {
            emit service->characteristicWritten(QLowEnergyCharacteristic(service, charHandle),
                                                newValue);
        }
        return S_OK;
    };
    hr = writeOp->put_Completed(
                Callback<IAsyncOperationCompletedHandler<GattCommunicationStatus>>(
                    writeCompletedLambda).Get());
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not register characteristic write callback",
                                   service, QLowEnergyService::CharacteristicWriteError, return)
}
 
void QLowEnergyControllerPrivateWinRT::writeDescriptor(
        const QSharedPointer<QLowEnergyServicePrivate> service,
        const QLowEnergyHandle charHandle,
        const QLowEnergyHandle descHandle,
        const QByteArray &newValue)
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__ << service << charHandle << descHandle << newValue;
    qCDebug(QT_BT_WINDOWS_SERVICE_THREAD) << __FUNCTION__ << "Changing service pointer from thread"
                                        << QThread::currentThread();
    Q_ASSERT(!service.isNull());
    if (role == QLowEnergyController::PeripheralRole) {
        service->setError(QLowEnergyService::DescriptorWriteError);
        Q_UNIMPLEMENTED();
        return;
    }
 
    if (!service->characteristicList.contains(charHandle)) {
        qCDebug(QT_BT_WINDOWS) << "Descriptor" << descHandle << "in characteristic" << charHandle
                             << "could not be found in service" << service->uuid;
        service->setError(QLowEnergyService::DescriptorWriteError);
        return;
    }
 
    const auto charData = service->characteristicList.value(charHandle);
 
    auto characteristicCallback = [descHandle, charHandle, service, newValue, this](
            ComPtr<IGattCharacteristic> characteristic) {
        writeDescriptorHelper(service, charHandle, descHandle, newValue, characteristic);
    };
 
    HRESULT hr = getNativeCharacteristic(service->uuid, charData.uuid, characteristicCallback);
    if (FAILED(hr)) {
        qCDebug(QT_BT_WINDOWS) << "Could not obtain native characteristic" << charData.uuid
                               << "from service" << service->uuid;
        service->setError(QLowEnergyService::DescriptorWriteError);
    }
}
 
void QLowEnergyControllerPrivateWinRT::writeDescriptorHelper(
        const QSharedPointer<QLowEnergyServicePrivate> service,
        const QLowEnergyHandle charHandle,
        const QLowEnergyHandle descHandle,
        const QByteArray &newValue,
        GattCharacteristicComPtr characteristic)
{
    // Get native descriptor
    const auto charData = service->characteristicList.value(charHandle);
    if (!charData.descriptorList.contains(descHandle)) {
        qCDebug(QT_BT_WINDOWS) << "Descriptor" << descHandle
                               << "could not be found in Characteristic" << charHandle;
    }
 
    QLowEnergyServicePrivate::DescData descData = charData.descriptorList.value(descHandle);
    if (descData.uuid ==
            QBluetoothUuid(QBluetoothUuid::DescriptorType::ClientCharacteristicConfiguration)) {
        GattClientCharacteristicConfigurationDescriptorValue value;
        quint16 intValue = qFromLittleEndian<quint16>(newValue);
        if (intValue & GattClientCharacteristicConfigurationDescriptorValue_Indicate
                && intValue & GattClientCharacteristicConfigurationDescriptorValue_Notify) {
            qCWarning(QT_BT_WINDOWS) << "Setting both Indicate and Notify "
                                        "is not supported on WinRT";
            value = GattClientCharacteristicConfigurationDescriptorValue(
                    (GattClientCharacteristicConfigurationDescriptorValue_Indicate
                     | GattClientCharacteristicConfigurationDescriptorValue_Notify));
        } else if (intValue & GattClientCharacteristicConfigurationDescriptorValue_Indicate) {
            value = GattClientCharacteristicConfigurationDescriptorValue_Indicate;
        } else if (intValue & GattClientCharacteristicConfigurationDescriptorValue_Notify) {
            value = GattClientCharacteristicConfigurationDescriptorValue_Notify;
        } else if (intValue == 0) {
            value = GattClientCharacteristicConfigurationDescriptorValue_None;
        } else {
            qCDebug(QT_BT_WINDOWS) << "Descriptor" << descHandle
                                   << "write operation failed: Invalid value";
            service->setError(QLowEnergyService::DescriptorWriteError);
            return;
        }
        ComPtr<IAsyncOperation<enum GattCommunicationStatus>> writeOp;
        HRESULT hr =
            characteristic->WriteClientCharacteristicConfigurationDescriptorAsync(value, &writeOp);
        CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not write client characteristic configuration",
                                       service, QLowEnergyService::DescriptorWriteError, return)
        QPointer<QLowEnergyControllerPrivateWinRT> thisPtr(this);
        auto writeCompletedLambda = [charHandle, descHandle, newValue, service, thisPtr]
                (IAsyncOperation<GattCommunicationStatus> *op, AsyncStatus status)
        {
            if (status == AsyncStatus::Canceled || status == AsyncStatus::Error) {
                qCDebug(QT_BT_WINDOWS) << "Descriptor" << descHandle << "write operation failed";
                service->setError(QLowEnergyService::DescriptorWriteError);
                return S_OK;
            }
            GattCommunicationStatus result;
            HRESULT hr;
            hr = op->GetResults(&result);
            CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain result for descriptor", service,
                                           QLowEnergyService::DescriptorWriteError, return S_OK)
            if (result != GattCommunicationStatus_Success) {
                qCWarning(QT_BT_WINDOWS) << "Descriptor" << descHandle << "write operation failed";
                service->setError(QLowEnergyService::DescriptorWriteError);
                return S_OK;
            }
            if (thisPtr)
                thisPtr->updateValueOfDescriptor(charHandle, descHandle, newValue, false);
            emit service->descriptorWritten(QLowEnergyDescriptor(service, charHandle, descHandle),
                                            newValue);
            return S_OK;
        };
        hr = writeOp->put_Completed(
                    Callback<IAsyncOperationCompletedHandler<GattCommunicationStatus >>(
                        writeCompletedLambda).Get());
        CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not register descriptor write callback",
                                       service, QLowEnergyService::DescriptorWriteError, return)
        return;
    }
 
    ComPtr<IGattCharacteristic3> characteristic3;
    HRESULT hr = characteristic.As(&characteristic3);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not cast characteristic",
                                   service, QLowEnergyService::DescriptorWriteError, return)
    ComPtr<IAsyncOperation<GattDescriptorsResult *>> op;
    hr = characteristic3->GetDescriptorsForUuidAsync(descData.uuid, &op);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain descriptor from Uuid",
                                   service, QLowEnergyService::DescriptorWriteError, return)
    ComPtr<IGattDescriptorsResult> result;
    hr = QWinRTFunctions::await(op, result.GetAddressOf(),
                                QWinRTFunctions::ProcessMainThreadEvents, 5000);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not await descriptor operation",
                                   service, QLowEnergyService::DescriptorWriteError, return)
    GattCommunicationStatus commStatus;
    hr = result->get_Status(&commStatus);
    if (FAILED(hr) || commStatus != GattCommunicationStatus_Success) {
        qCWarning(QT_BT_WINDOWS) << "Descriptor operation failed";
        service->setError(QLowEnergyService::DescriptorWriteError);
        return;
    }
    ComPtr<IVectorView<GattDescriptor *>> descriptors;
    hr = result->get_Descriptors(&descriptors);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain list of descriptors",
                                   service, QLowEnergyService::DescriptorWriteError, return)
    uint size;
    hr = descriptors->get_Size(&size);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain list of descriptors' size",
                                   service, QLowEnergyService::DescriptorWriteError, return)
    if (size == 0) {
        qCWarning(QT_BT_WINDOWS) << "No descriptor with uuid" << descData.uuid << "was found.";
        return;
    } else if (size > 1) {
        qCWarning(QT_BT_WINDOWS) << "There is more than 1 descriptor with uuid" << descData.uuid;
    }
    ComPtr<IGattDescriptor> descriptor;
    hr = descriptors->GetAt(0, &descriptor);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain descriptor",
                                   service, QLowEnergyService::DescriptorWriteError, return)
    ComPtr<ABI::Windows::Storage::Streams::IBufferFactory> bufferFactory;
    hr = GetActivationFactory(
                HStringReference(RuntimeClass_Windows_Storage_Streams_Buffer).Get(),
                &bufferFactory);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain buffer factory",
                                   service, QLowEnergyService::DescriptorWriteError, return)
    ComPtr<ABI::Windows::Storage::Streams::IBuffer> buffer;
    const quint32 length = quint32(newValue.length());
    hr = bufferFactory->Create(length, &buffer);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not create buffer",
                                   service, QLowEnergyService::DescriptorWriteError, return)
    hr = buffer->put_Length(length);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not set buffer length",
                                   service, QLowEnergyService::DescriptorWriteError, return)
    ComPtr<Windows::Storage::Streams::IBufferByteAccess> byteAccess;
    hr = buffer.As(&byteAccess);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not cast buffer",
                                   service, QLowEnergyService::DescriptorWriteError, return)
    byte *bytes;
    hr = byteAccess->Buffer(&bytes);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not set buffer",
                                   service, QLowEnergyService::DescriptorWriteError, return)
    memcpy(bytes, newValue, length);
    ComPtr<IAsyncOperation<GattCommunicationStatus>> writeOp;
    hr = descriptor->WriteValueAsync(buffer.Get(), &writeOp);
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not write descriptor value",
                                   service, QLowEnergyService::DescriptorWriteError, return)
    QPointer<QLowEnergyControllerPrivateWinRT> thisPtr(this);
    auto writeCompletedLambda = [charHandle, descHandle, newValue, service, thisPtr]
            (IAsyncOperation<GattCommunicationStatus> *op, AsyncStatus status)
    {
        if (status == AsyncStatus::Canceled || status == AsyncStatus::Error) {
            qCDebug(QT_BT_WINDOWS) << "Descriptor" << descHandle << "write operation failed";
            service->setError(QLowEnergyService::DescriptorWriteError);
            return S_OK;
        }
        GattCommunicationStatus result;
        HRESULT hr;
        hr = op->GetResults(&result);
        CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not obtain result for descriptor", service,
                                       QLowEnergyService::DescriptorWriteError, return S_OK)
        if (result != GattCommunicationStatus_Success) {
            qCDebug(QT_BT_WINDOWS) << "Descriptor" << descHandle << "write operation failed";
            service->setError(QLowEnergyService::DescriptorWriteError);
            return S_OK;
        }
        if (thisPtr)
            thisPtr->updateValueOfDescriptor(charHandle, descHandle, newValue, false);
        emit service->descriptorWritten(QLowEnergyDescriptor(service, charHandle, descHandle),
                                        newValue);
        return S_OK;
    };
    hr = writeOp->put_Completed(
                Callback<IAsyncOperationCompletedHandler<GattCommunicationStatus>>(
                    writeCompletedLambda).Get());
    CHECK_HR_AND_SET_SERVICE_ERROR(hr, "Could not register descriptor write callback",
                                   service, QLowEnergyService::DescriptorWriteError, return)
}
 
void QLowEnergyControllerPrivateWinRT::addToGenericAttributeList(const QLowEnergyServiceData &,
                                                                    QLowEnergyHandle)
{
    Q_UNIMPLEMENTED();
}
 
int QLowEnergyControllerPrivateWinRT::mtu() const
{
    uint16_t mtu = 23;
    if (!mGattSession) {
        qCDebug(QT_BT_WINDOWS) << "mtu queried before GattSession available. Using default mtu.";
        return mtu;
    }
 
    HRESULT hr = mGattSession->get_MaxPduSize(&mtu);
    RETURN_IF_FAILED("could not obtain MTU size", return mtu);
    qCDebug(QT_BT_WINDOWS) << "mtu determined to be" << mtu;
    return mtu;
}
 
void QLowEnergyControllerPrivateWinRT::handleCharacteristicChanged(
        quint16 charHandle, const QByteArray &data)
{
    qCDebug(QT_BT_WINDOWS) << __FUNCTION__ << charHandle << data;
    qCDebug(QT_BT_WINDOWS_SERVICE_THREAD) << __FUNCTION__ << "Changing service pointer from thread"
                                        << QThread::currentThread();
    QSharedPointer<QLowEnergyServicePrivate> service =
            serviceForHandle(charHandle);
    if (service.isNull())
        return;
 
    qCDebug(QT_BT_WINDOWS) << "Characteristic change notification" << service->uuid
                           << charHandle << data.toHex();
 
    QLowEnergyCharacteristic characteristic = characteristicForHandle(charHandle);
    if (!characteristic.isValid()) {
        qCWarning(QT_BT_WINDOWS) << "characteristicChanged: Cannot find characteristic";
        return;
    }
 
    // only update cache when property is readable. Otherwise it remains
    // empty.
    if (characteristic.properties() & QLowEnergyCharacteristic::Read)
        updateValueOfCharacteristic(characteristic.attributeHandle(),
                                data, false);
    emit service->characteristicChanged(characteristic, data);
}
 
void QLowEnergyControllerPrivateWinRT::handleServiceHandlerError(const QString &error)
{
    if (state != QLowEnergyController::DiscoveringState)
        return;
 
    qCWarning(QT_BT_WINDOWS) << "Error while discovering services:" << error;
    setState(QLowEnergyController::UnconnectedState);
    setError(QLowEnergyController::ConnectionError);
}
 
void QLowEnergyControllerPrivateWinRT::handleConnectionError(const char *logMessage)
{
    qCWarning(QT_BT_WINDOWS) << logMessage;
    setError(QLowEnergyController::ConnectionError);
    setState(QLowEnergyController::UnconnectedState);
    unregisterFromStatusChanges();
    unregisterFromMtuChanges();
}
 
QT_END_NAMESPACE
 
#include "qlowenergycontroller_winrt.moc"