controller.hpp

Go to the documentation of this file.

//
// Created by spak on 10/2/21.
//
 
#ifndef LIBGULLIBLE_CONTROLLER_HPP
#define LIBGULLIBLE_CONTROLLER_HPP
 
#include <ble/service.hpp>
#include <vector>
 
namespace ble {
    namespace {
        using namespace std::chrono_literals;
    }
 
    enum struct device_appearance : std::uint16_t {
        none = 0x0,
        multicolor_led_array = 0x07C6
    };
 
    struct device_name_characteristic final : public characteristic_base {
        explicit device_name_characteristic(uuid u);
 
    protected:
        [[nodiscard]] retcode do_read(mlab::bin_data &data, std::uint16_t, std::uint16_t) override;
 
        [[nodiscard]] retcode do_write(mlab::bin_data const &data, std::uint16_t, std::uint16_t) override;
    };
 
    class controller : public mlab::uniquely_tracked {
 
        template <class T>
        struct dyn_c_vec {
            std::unique_ptr<T[]> v = nullptr;
            std::size_t size = 0;
 
            void resize(std::size_t new_size) {
                v = std::unique_ptr<T[]>(new T[new_size]);
                size = new_size;
            }
        };
 
        std::vector<service::snapshot> _svc_snapshots;
        std::unique_ptr<ble_gatt_svc_def[]> _nimble_svc_defs;
        dyn_c_vec<ble_uuid16_t> _nimble_svc_uuid16;
        dyn_c_vec<ble_uuid32_t> _nimble_svc_uuid32;
        dyn_c_vec<ble_uuid128_t> _nimble_svc_uuid128;
        std::uint8_t _own_address;
        bool _auto_advertise;
 
        static void _nimble_main_task(void *);
 
        static void _nimble_reset_cbk(int reason);
 
        static void _nimble_sync_cbk();
 
        static int _nimble_on_gap_event_cbk(ble_gap_event *event, void *tracker);
 
    protected:
        void ensure_own_address();
 
        void configure_services(bool start_gatts_manually = false);
 
    public:
        explicit controller(std::vector<service> const &svcs);
 
        controller(controller &&)
 
                noexcept = delete;
 
        controller(controller const &) = delete;
 
        controller &operator=(controller &&)
 
                noexcept = delete;
 
        controller &operator=(controller const &) = delete;
 
        void start();
 
        void stop();
 
        void advertise_start(std::chrono::milliseconds duration = 0ms);
 
        void advertise_stop();
 
        [[nodiscard]] bool is_running() const;
 
        [[nodiscard]] bool is_advertising() const;
 
        [[nodiscard]] inline bool auto_advertise() const;
 
        inline void set_auto_advertise(bool aa);
 
        [[nodiscard]] std::string get_device_name() const;
 
        [[nodiscard]] std::uint16_t get_device_appearance() const;
 
        void set_device_name(std::string const &new_name);
 
        void set_device_appearance(std::uint16_t new_appearance);
 
        inline void set_device_appearance(device_appearance new_appearance);
 
        [[nodiscard]] inline std::vector<service::snapshot> const &services() const;
 
        ~controller();
    };
 
    enum struct gap_event : std::uint8_t {
        connect = BLE_GAP_EVENT_CONNECT,
        disconnect = BLE_GAP_EVENT_DISCONNECT,
        conn_update = BLE_GAP_EVENT_CONN_UPDATE,
        conn_update_req = BLE_GAP_EVENT_CONN_UPDATE_REQ,
        l2cap_update_req = BLE_GAP_EVENT_L2CAP_UPDATE_REQ,
        term_failure = BLE_GAP_EVENT_TERM_FAILURE,
        disc = BLE_GAP_EVENT_DISC,
        disc_complete = BLE_GAP_EVENT_DISC_COMPLETE,
        adv_complete = BLE_GAP_EVENT_ADV_COMPLETE,
        enc_change = BLE_GAP_EVENT_ENC_CHANGE,
        passkey_action = BLE_GAP_EVENT_PASSKEY_ACTION,
        notify_rx = BLE_GAP_EVENT_NOTIFY_RX,
        notify_tx = BLE_GAP_EVENT_NOTIFY_TX,
        subscribe = BLE_GAP_EVENT_SUBSCRIBE,
        mtu = BLE_GAP_EVENT_MTU,
        identity_resolved = BLE_GAP_EVENT_IDENTITY_RESOLVED,
        repeat_pairing = BLE_GAP_EVENT_REPEAT_PAIRING,
        phy_update_complete = BLE_GAP_EVENT_PHY_UPDATE_COMPLETE,
        ext_disc = BLE_GAP_EVENT_EXT_DISC,
        periodic_sync = BLE_GAP_EVENT_PERIODIC_SYNC,
        periodic_report = BLE_GAP_EVENT_PERIODIC_REPORT,
        periodic_sync_lost = BLE_GAP_EVENT_PERIODIC_SYNC_LOST,
        scan_req_rcvd = BLE_GAP_EVENT_SCAN_REQ_RCVD
    };
 
    [[nodiscard]] const char *to_string(gap_event evt);
}// namespace ble
 
namespace ble {
 
    std::vector<service::snapshot> const &controller::services() const {
        return _svc_snapshots;
    }
 
    void controller::set_device_appearance(device_appearance new_appearance) {
        set_device_appearance(static_cast<std::uint16_t>(new_appearance));
    }
 
    bool controller::auto_advertise() const {
        return _auto_advertise;
    }
 
    void controller::set_auto_advertise(bool aa) {
        _auto_advertise = aa;
    }
 
 
}// namespace ble
 
#endif//LIBGULLIBLE_CONTROLLER_HPP