Characteristic.h

Go to the documentation of this file.

 
#pragma once
 
#include <type_traits> // underlying_type
 
namespace Systemic::BluetoothLE
{
    class Peripheral;
 
    enum CharacteristicProperties
    {
        None = 0,
 
        Broadcast = 0x001,
 
        Read = 0x002,
 
        WriteWithoutResponse = 0x004,
 
        Write = 0x008,
 
        Notify = 0x010,
 
        Indicate = 0x020,
 
        SignedWrite = 0x040,
 
        ExtendedProperties = 0x080,
 
        NotifyEncryptionRequired = 0x100,
 
        IndicateEncryptionRequired = 0x200,
    };
 
    class Characteristic
    {
        using GattCharacteristic = winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattCharacteristic;
        using GattValueChangedEventArgs = winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattValueChangedEventArgs;
 
        // Characteristic
        GattCharacteristic _characteristic{ nullptr };
 
        // The user callback for value changes
        std::function<void(const std::vector<std::uint8_t>&)> _onValueChanged{};
 
        // Value change
        winrt::event_token _valueChangedToken{};
        std::recursive_mutex _subscribeMtx{};
 
    public:
 
        ~Characteristic()
        {
            if (_characteristic)
            {
                _characteristic.ValueChanged(_valueChangedToken);
                _characteristic = nullptr;
            }
        }
 
 
        std::uint16_t handle() const
        {
            return _characteristic.AttributeHandle();
        }
 
        winrt::guid uuid() const
        {
            return _characteristic.Uuid();
        }
 
        std::underlying_type<CharacteristicProperties>::type properties() const
        {
            return static_cast<std::underlying_type<CharacteristicProperties>::type>(
                _characteristic.CharacteristicProperties());
        }
 
        bool canWrite() const
        {
            return properties() & CharacteristicProperties::Write;
        }
 
        bool canRead() const
        {
            return properties() & CharacteristicProperties::Read;
        }
 
        bool canNotify() const
        {
            return properties() & CharacteristicProperties::Notify;
        }
 
 
        std::future<std::vector<std::uint8_t>> readValueAsync()
        {
            // TODO return error code
 
            // Read from characteristic
            auto result = co_await _characteristic.ReadValueAsync();
            co_return Internal::dataBufferToBytesVector(result.Value());
        }
 
        std::future<BleRequestStatus> writeAsync(const std::vector<std::uint8_t>& data, bool withoutResponse = false)
        {
            // TODO use std::span, test with empty buffer
            using namespace winrt::Windows::Devices::Bluetooth::GenericAttributeProfile;
 
            // Write to characteristic
            auto options = withoutResponse ? GattWriteOption::WriteWithoutResponse : GattWriteOption::WriteWithResponse;
            auto result = co_await _characteristic.WriteValueAsync(Internal::bytesVectorToDataBuffer(data), options);
 
            co_return result == GattCommunicationStatus::Success ? BleRequestStatus::Success : BleRequestStatus::Error;
        }
 
        std::future<BleRequestStatus> subscribeAsync(const std::function<void(const std::vector<std::uint8_t>&)>& onValueChanged)
        {
            using namespace winrt::Windows::Devices::Bluetooth::GenericAttributeProfile;
 
            // Check parameters
            if (!onValueChanged) co_return BleRequestStatus::InvalidParameters;
            if (!canNotify()) co_return BleRequestStatus::NotSupported;
 
            {
                std::lock_guard lock{ _subscribeMtx };
 
                // Store the callback and subscribe
                _onValueChanged = onValueChanged;
                if (!_valueChangedToken)
                {
                    _valueChangedToken = _characteristic.ValueChanged({ this, &Characteristic::onValueChanged });
                }
            }
 
            // Update characteristic configuration
            auto result = co_await _characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(
                GattClientCharacteristicConfigurationDescriptorValue::Notify);
 
            co_return result == GattCommunicationStatus::Success ? BleRequestStatus::Success : BleRequestStatus::Error;
        }
 
        std::future<BleRequestStatus> unsubscribeAsync()
        {
            using namespace winrt::Windows::Devices::Bluetooth::GenericAttributeProfile;
 
            {
                // Check if subscribed
                std::lock_guard lock{ _subscribeMtx };
                if (!_onValueChanged)
                {
                    co_return BleRequestStatus::Success;
                }
 
                // Forget the callback
                _onValueChanged = nullptr;
            }
 
            // Unsubscribe
            _characteristic.ValueChanged(_valueChangedToken);
            _valueChangedToken = winrt::event_token{};
 
            // Update characteristic configuration
            auto result = co_await _characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(
                GattClientCharacteristicConfigurationDescriptorValue::None);
 
            co_return result == GattCommunicationStatus::Success ? BleRequestStatus::Success : BleRequestStatus::Error;
        }
 
    private:
        friend std::future<BleRequestStatus> Peripheral::connectAsync(std::vector<winrt::guid>, bool);
 
        // Initialize a new instance with a GattCharacteristic object
        explicit Characteristic(GattCharacteristic characteristic)
            : _characteristic{ characteristic }
        {
        }
 
        // Called when subscribed to the characteristic and its value changes
        void onValueChanged(GattCharacteristic _, GattValueChangedEventArgs args)
        {
            // Safely get the callback
            std::function<void(const std::vector<std::uint8_t>&)> callback{};
            {
                std::lock_guard lock{ _subscribeMtx };
                callback = _onValueChanged;
            }
 
            if (callback)
            {
                callback(Internal::dataBufferToBytesVector(args.CharacteristicValue()));
            }
        }
    };
}