Service.h

Go to the documentation of this file.

 
#pragma once
 
namespace Systemic::BluetoothLE
{
    class Peripheral;
    class Characteristic;
 
    class Service
    {
        using GattDeviceService = winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattDeviceService;
 
        // Keep a weak pointer to the peripheral so it can be accessed
        std::weak_ptr<Peripheral> _peripheral;
 
        // Service
        GattDeviceService _service{ nullptr };
 
        // Characteristics (there may be more than one characteristic instance for a given UUID)
        std::unordered_map<winrt::guid, std::vector<std::shared_ptr<Characteristic>>> _characteristics{};
 
    public:
 
        ~Service()
        {
            _characteristics.clear();
 
            if (_service)
            {
                _service.Close();
                _service = nullptr;
            }
        }
 
 
        std::uint16_t handle() const
        {
            return _service.AttributeHandle();
        }
 
        winrt::guid uuid() const
        {
            return _service.Uuid();
        }
 
        std::shared_ptr<const Peripheral> peripheral() const
        {
            return _peripheral.lock();
        }
 
        std::shared_ptr<Peripheral> peripheral()
        {
            return _peripheral.lock();
        }
 
 
        std::shared_ptr<Characteristic> getCharacteristic(const winrt::guid& uuid)
        {
            auto it = _characteristics.find(uuid);
            bool found = (it != _characteristics.end()) && (!it->second.empty());
            return found ? it->second[0] : nullptr;
        }
 
        const std::vector<std::shared_ptr<Characteristic>> getCharacteristics(const winrt::guid& uuid)
        {
            return _characteristics.find(uuid)->second;
        }
 
        void copyCharacteristics(std::vector<std::shared_ptr<Characteristic>>& outCharacteristics)
        {
            size_t _characteristicsCount = 0;
            for (auto& [_, instances] : _characteristics)
            {
                _characteristicsCount += instances.size();
            }
            outCharacteristics.reserve(outCharacteristics.size() + _characteristicsCount);
            for (auto& [_, instances] : _characteristics)
            {
                for (auto& c : instances)
                {
                    outCharacteristics.emplace_back(c);
                }
            }
        }
 
 
    private:
        friend Peripheral;
 
        // Initializes a new instance of Service for a Peripheral and GattDeviceService,
        // and with a list of characteristics.
        Service(
            std::weak_ptr<Peripheral> peripheral,
            GattDeviceService service,
            std::unordered_map<winrt::guid, std::vector<std::shared_ptr<Characteristic>>> characteristics)
            :
            _peripheral{ peripheral },
            _service{ service },
            _characteristics{ characteristics }
        {
        }
    };
}