qlowenergycontroller_winrt_p.h

// Copyright (C) 2017 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

#ifndef QLOWENERGYCONTROLLERPRIVATEWINRT_P_H

#define QLOWENERGYCONTROLLERPRIVATEWINRT_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include <qglobal.h>

#include <QtCore/QList>

#include <QtCore/QQueue>

#include <QtBluetooth/qbluetooth.h>

#include <QtBluetooth/qlowenergycharacteristic.h>

#include <QtBluetooth/qlowenergyservicedata.h>

#include "qlowenergycontroller.h"

#include "qlowenergycontrollerbase_p.h"

#include <winrt/Windows.Foundation.h>

#include <winrt/Windows.Devices.Bluetooth.h>

#include <winrt/Windows.Devices.Bluetooth.GenericAttributeProfile.h>

using namespace winrt::Windows::Devices::Bluetooth;

using namespace winrt::Windows::Devices::Bluetooth::GenericAttributeProfile;

namespace winrt

    using AsyncStatus = Windows::Foundation::AsyncStatus;

    using IInspectable = Windows::Foundation::IInspectable;

#include <functional>

QT_BEGIN_NAMESPACE

class QLowEnergyServiceData;

class QTimer;

extern void registerQLowEnergyControllerMetaType();

class QLowEnergyControllerPrivateWinRT final : public QLowEnergyControllerPrivate

    Q_OBJECT

public:

    QLowEnergyControllerPrivateWinRT();

    ~QLowEnergyControllerPrivateWinRT() override;

    void init() override;

    void connectToDevice() override;

    void disconnectFromDevice() override;

    void discoverServices() override;

    void discoverServiceDetails(const QBluetoothUuid &service,

                                QLowEnergyService::DiscoveryMode mode) override;

    void startAdvertising(const QLowEnergyAdvertisingParameters &params,

                          const QLowEnergyAdvertisingData &advertisingData,

                          const QLowEnergyAdvertisingData &scanResponseData) override;

    void stopAdvertising() override;

    void requestConnectionUpdate(const QLowEnergyConnectionParameters &params) override;

    // read data

    void readCharacteristic(const QSharedPointer<QLowEnergyServicePrivate> service,

                            const QLowEnergyHandle charHandle) override;

    void readDescriptor(const QSharedPointer<QLowEnergyServicePrivate> service,

                        const QLowEnergyHandle charHandle,

                        const QLowEnergyHandle descriptorHandle) override;

    // write data

    void writeCharacteristic(const QSharedPointer<QLowEnergyServicePrivate> service,

                             const QLowEnergyHandle charHandle,

                             const QByteArray &newValue, QLowEnergyService::WriteMode mode) override;

    void writeDescriptor(const QSharedPointer<QLowEnergyServicePrivate> service,

                         const QLowEnergyHandle charHandle,

                         const QLowEnergyHandle descriptorHandle,

                         const QByteArray &newValue) override;

    void addToGenericAttributeList(const QLowEnergyServiceData &service,

                                   QLowEnergyHandle startHandle) override;

    int mtu() const override;

signals:

    void characteristicChanged(quint16 charHandle, const QByteArray &data);

    void abortConnection();

private slots:

    void handleCharacteristicChanged(quint16 charHandle, const QByteArray &data);

    void handleServiceHandlerError(const QString &error);

private:

    void handleConnectionError(const char *logMessage);

    BluetoothLEDevice mDevice = nullptr;

    GattSession mGattSession = nullptr;

    winrt::event_token mStatusChangedToken{ 0 };

    winrt::event_token mMtuChangedToken{ 0 };

    struct ValueChangedEntry {

        ValueChangedEntry() {}

        ValueChangedEntry(GattCharacteristic c,

                          winrt::event_token t)

            : characteristic(c)

            , token(t)

        GattCharacteristic characteristic = nullptr;

        winrt::event_token token = { 0 };

};

    QList<ValueChangedEntry> mValueChangedTokens;

    QMap<QBluetoothUuid, GattDeviceService> m_openedServices;

    QSet<QBluetoothUuid> m_requestDetailsServiceUuids;

    using NativeServiceCallback = std::function<void(GattDeviceService)>;

    bool getNativeService(const QBluetoothUuid &serviceUuid, NativeServiceCallback callback);

    using NativeCharacteristicCallback = std::function<void(GattCharacteristic)>;

    bool getNativeCharacteristic(const QBluetoothUuid &serviceUuid,

        const QBluetoothUuid &charUuid,

        NativeCharacteristicCallback callback);

    void registerForValueChanges(const QBluetoothUuid &serviceUuid, const QBluetoothUuid &charUuid);

    void unregisterFromValueChanges();

    void onValueChange(GattCharacteristic characteristic, GattValueChangedEventArgs const &args);

    void onMtuChange(GattSession session, winrt::IInspectable args);

    bool registerForMtuChanges();

    void unregisterFromMtuChanges();

    bool registerForStatusChanges();

    void unregisterFromStatusChanges();

    void onStatusChange(BluetoothLEDevice dev, winrt::IInspectable args);

    void obtainIncludedServices(QSharedPointer<QLowEnergyServicePrivate> servicePointer,

        GattDeviceService nativeService);

    void onServiceDiscoveryFinished(winrt::Windows::Foundation::IAsyncOperation<GattDeviceServicesResult> const &op,

                                    winrt::AsyncStatus status);

    void readCharacteristicHelper(const QSharedPointer<QLowEnergyServicePrivate> service,

                                  const QLowEnergyHandle charHandle,

                                  GattCharacteristic characteristic);

    void readDescriptorHelper(const QSharedPointer<QLowEnergyServicePrivate> service,

                              const QLowEnergyHandle charHandle,

                              const QLowEnergyHandle descriptorHandle,

                              GattCharacteristic characteristic);

    void writeCharacteristicHelper(const QSharedPointer<QLowEnergyServicePrivate> service,

                                   const QLowEnergyHandle charHandle, const QByteArray &newValue,

                                   bool writeWithResponse,

                                   GattCharacteristic characteristic);

    void writeDescriptorHelper(const QSharedPointer<QLowEnergyServicePrivate> service,

                               const QLowEnergyHandle charHandle,

                               const QLowEnergyHandle descriptorHandle,

                               const QByteArray &newValue,

                               GattCharacteristic characteristic);

    void discoverServiceDetailsHelper(const QBluetoothUuid &service,

                                      QLowEnergyService::DiscoveryMode mode,

                                      GattDeviceService deviceService);

    void clearAllServices();

    void closeAndRemoveService(const QBluetoothUuid &uuid);

};

QT_END_NAMESPACE

#endif // QLOWENERGYCONTROLLERPRIVATEWINRT_P_H