characteristic.hpp

Go to the documentation of this file.

//
// Created by spak on 9/23/21.
//
 
#ifndef LIBGULLIBLE_CHARACTERISTIC_HPP
#define LIBGULLIBLE_CHARACTERISTIC_HPP
 
#include <ble/uuid.hpp>
#include <mlab/bin_data.hpp>
#include <mlab/observable.hpp>
#include <mlab/unique_tracker.hpp>
#include <utility>
 
namespace ble {
 
    enum struct retcode : int {
        ok = 0,
        invalid_handle = BLE_ATT_ERR_INVALID_HANDLE,
        read_not_permitted = BLE_ATT_ERR_READ_NOT_PERMITTED,
        write_not_permitted = BLE_ATT_ERR_WRITE_NOT_PERMITTED,
        invalid_pdu = BLE_ATT_ERR_INVALID_PDU,
        insufficient_authen = BLE_ATT_ERR_INSUFFICIENT_AUTHEN,
        req_not_supported = BLE_ATT_ERR_REQ_NOT_SUPPORTED,
        invalid_offset = BLE_ATT_ERR_INVALID_OFFSET,
        insufficient_author = BLE_ATT_ERR_INSUFFICIENT_AUTHOR,
        prepare_queue_full = BLE_ATT_ERR_PREPARE_QUEUE_FULL,
        attr_not_found = BLE_ATT_ERR_ATTR_NOT_FOUND,
        attr_not_long = BLE_ATT_ERR_ATTR_NOT_LONG,
        insufficient_key_sz = BLE_ATT_ERR_INSUFFICIENT_KEY_SZ,
        invalid_attr_value_len = BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN,
        unlikely = BLE_ATT_ERR_UNLIKELY,
        insufficient_enc = BLE_ATT_ERR_INSUFFICIENT_ENC,
        unsupported_group = BLE_ATT_ERR_UNSUPPORTED_GROUP,
        insufficient_res = BLE_ATT_ERR_INSUFFICIENT_RES
    };
 
    enum struct access_type : std::uint8_t {
        none = 0b00,
        r = 0b01,
        w = 0b10,
        rw = 0b11
    };
 
    [[nodiscard]] inline bool operator&(access_type l, access_type r);
 
    [[nodiscard]] inline access_type operator|(access_type l, access_type r);
 
    [[nodiscard]] inline std::uint16_t to_nimble(access_type a);
 
    class characteristic_base
        : public mlab::uniquely_tracked,
          public std::enable_shared_from_this<characteristic_base> {
 
        uuid _uuid;
        std::unique_ptr<ble_uuid_any_t> _nimble_uuid;
        access_type _access;
        mlab::bin_data _buffer;
 
        static int _nimble_characteristic_access_callback(std::uint16_t conn_handle, std::uint16_t attr_handle,
                                                          ble_gatt_access_ctxt *ctxt, void *tracker);
 
    protected:
        [[nodiscard]] virtual retcode on_access(std::uint16_t conn_handle, std::uint16_t attr_handle,
                                                ble_gatt_access_ctxt &ctxt);
 
        [[nodiscard]] virtual retcode on_read(std::uint16_t conn_handle, std::uint16_t attr_handle,
                                              ble_gatt_access_ctxt &ctxt);
 
        [[nodiscard]] virtual retcode on_write(std::uint16_t conn_handle, std::uint16_t attr_handle,
                                               ble_gatt_access_ctxt &ctxt);
 
        [[nodiscard]] virtual retcode do_read(mlab::bin_data &data, std::uint16_t conn_handle,
                                              std::uint16_t attr_handle) = 0;
 
        [[nodiscard]] virtual retcode do_write(mlab::bin_data const &data, std::uint16_t conn_handle,
                                               std::uint16_t attr_handle) = 0;
 
    public:
        static constexpr ble_gatt_chr_def void_definition = {
                .uuid = nullptr,
                .access_cb = nullptr,
                .arg = nullptr,
                .descriptors = nullptr,
                .flags = 0,
                .min_key_size = 0,
                .val_handle = nullptr};
 
        characteristic_base(uuid u, access_type access);
 
        [[nodiscard]] inline access_type access() const;
 
        [[nodiscard]] inline uuid const &chr_uuid() const;
 
        [[nodiscard]] ble_gatt_chr_def get_definition() const;
 
        virtual ~characteristic_base() = default;
    };
 
    namespace impl {
 
        template <class T, bool>
        class stored_characteristic_base : public characteristic_base {
            std::shared_ptr<mlab::observable<T>> _value;
 
        public:
            stored_characteristic_base(uuid const &u, access_type access,
                                       std::shared_ptr<mlab::observable<T>> init = nullptr);
 
            stored_characteristic_base(uuid const &u, access_type access, T init);
 
            [[nodiscard]] inline mlab::observable_cref<T> value() const;
 
            [[nodiscard]] inline mlab::observable_ref<T> value();
 
            [[nodiscard]] inline std::shared_ptr<mlab::observable<T>> const &value_ptr() const;
        };
 
        template <class T>
        class stored_characteristic_base<T, true> : public stored_characteristic_base<T, false> {
        protected:
            [[nodiscard]] retcode do_read(mlab::bin_data &data, std::uint16_t conn_handle,
                                          std::uint16_t attr_handle) override;
 
            [[nodiscard]] retcode do_write(mlab::bin_data const &data, std::uint16_t conn_handle,
                                           std::uint16_t attr_handle) override;
 
        public:
            using stored_characteristic_base<T, false>::value;
            using stored_characteristic_base<T, false>::value_ptr;
            using stored_characteristic_base<T, false>::stored_characteristic_base;
        };
 
    }// namespace impl
 
    template <class T>
    class stored_characteristic
        : public impl::stored_characteristic_base<
                  T, mlab::bin_data::is_injectable<T>::value and mlab::bin_stream::is_extractable<T>::value> {
    public:
        static constexpr bool has_synthetic_rw_methods = mlab::bin_data::is_injectable<T>::value and
                                                         mlab::bin_stream::is_extractable<T>::value;
 
        using impl::stored_characteristic_base<T, has_synthetic_rw_methods>::value;
        using impl::stored_characteristic_base<T, has_synthetic_rw_methods>::value_ptr;
        using impl::stored_characteristic_base<T, has_synthetic_rw_methods>::stored_characteristic_base;
    };
 
}// namespace ble
 
namespace ble {
 
    template <class T, bool B>
    impl::stored_characteristic_base<T, B>::stored_characteristic_base(
            uuid const &u, access_type access, std::shared_ptr<mlab::observable<T>> init)
        : characteristic_base{u, access},
          _value{init != nullptr ? std::move(init) : std::make_shared<mlab::observable<T>>()} {}
 
    template <class T, bool B>
    impl::stored_characteristic_base<T, B>::stored_characteristic_base(
            uuid const &u, access_type access, T init)
        : characteristic_base{u, access},
          _value{std::make_shared<mlab::observable<T>>(std::forward<T>(init))} {}
 
 
    template <class T, bool B>
    mlab::observable_cref<T> impl::stored_characteristic_base<T, B>::value() const {
        return _value->cref();
    }
 
    template <class T, bool B>
    std::shared_ptr<mlab::observable<T>> const &impl::stored_characteristic_base<T, B>::value_ptr() const {
        return _value;
    }
 
    template <class T, bool B>
    mlab::observable_ref<T> impl::stored_characteristic_base<T, B>::value() {
        return _value->ref();
    }
 
    template <class T>
    retcode impl::stored_characteristic_base<T, true>::do_read(mlab::bin_data &data, std::uint16_t, std::uint16_t) {
        data << static_cast<T>(value());
        return retcode::ok;
    }
 
    template <class T>
    retcode
    impl::stored_characteristic_base<T, true>::do_write(mlab::bin_data const &data, std::uint16_t, std::uint16_t) {
        mlab::bin_stream s{data};
        T obj{};
        s >> obj;
        if (s.bad()) {
            return retcode::req_not_supported;
        }
        value() = std::forward<T>(obj);
        return retcode::ok;
    }
 
    access_type characteristic_base::access() const {
        return _access;
    }
 
    uuid const &characteristic_base::chr_uuid() const {
        return _uuid;
    }
 
    std::uint16_t to_nimble(access_type a) {
        switch (a) {
            case access_type::r:
                return BLE_GATT_CHR_F_READ;
            case access_type::w:
                return BLE_GATT_CHR_F_WRITE;
            case access_type::rw:
                return BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_WRITE;
            default:
                [[fallthrough]];
            case access_type::none:
                return 0;
        }
    }
 
    bool operator&(access_type l, access_type r) {
        return (static_cast<std::uint8_t>(l) & static_cast<std::uint8_t>(r)) != 0;
    }
 
    access_type operator|(access_type l, access_type r) {
        return static_cast<access_type>(static_cast<std::uint8_t>(l) | static_cast<std::uint8_t>(r));
    }
}// namespace ble
 
 
#endif//LIBGULLIBLE_CHARACTERISTIC_HPP