qlowenergycontroller_winrt_p.h

Go to the documentation of this file.

// 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