BLEAPI.hpp

Go to the documentation of this file.

#pragma once
 
#include <Settings/NamespaceSettings.hpp>
 
#include "Util/compat.hpp"
 
#include <cstddef>
#include <cstdint>
 
BEGIN_CS_NAMESPACE
 
struct BLEConnectionHandle {
    uint16_t conn = 0xFFFF;
    explicit operator bool() const { return conn != 0xFFFF; }
 
#if __cplusplus < 201402L
    BLEConnectionHandle() = default;
    BLEConnectionHandle(uint16_t conn) : conn {conn} {}
#endif
};
 
struct BLECharacteristicHandle {
    uint16_t characteristic = 0xFFFF;
    explicit operator bool() const { return characteristic != 0xFFFF; }
 
#if __cplusplus < 201402L
    BLECharacteristicHandle() = default;
    BLECharacteristicHandle(uint16_t characteristic)
        : characteristic {characteristic} {}
#endif
};
 
struct BLEDataView {
    const uint8_t *data = nullptr;
    uint16_t length = 0;
    explicit operator bool() const { return length > 0; }
 
#if __cplusplus < 201402L
    BLEDataView() = default;
    BLEDataView(const uint8_t *data, uint16_t length)
        : data {data}, length {length} {}
#endif
};
 
enum class BLEDataType : uint8_t {
    None = 0,     
    Packet,       
    Continuation, 
};
 
class BLEDataGenerator {
  public:
    BLEDataView operator()();
    void clear();
    explicit operator bool() const { return instance; }
 
    BLEDataGenerator() = default;
    template <class T, class... Args>
    BLEDataGenerator(compat::in_place_type_t<T>, Args &&...args);
    template <class T>
    BLEDataGenerator(compat::in_place_t, T &&t);
    BLEDataGenerator(const BLEDataGenerator &) = delete;
    BLEDataGenerator &operator=(const BLEDataGenerator &) = delete;
    BLEDataGenerator(BLEDataGenerator &&other) noexcept;
    BLEDataGenerator &operator=(BLEDataGenerator &&other) noexcept;
    ~BLEDataGenerator() { clear(); }
 
  private:
    struct Iface;
    template <class T>
    struct Impl;
    using buffer_align_t = max_align_t;
    static constexpr size_t capacity = 4 * sizeof(void *) - sizeof(Iface *);
    alignas(buffer_align_t) compat::byte storage[capacity];
    Iface *instance = nullptr;
};
 
enum class BLEDataLifetime {
    ConsumeImmediately,
    Managed,
};
 
class MIDIBLEInstance {
  public:
    virtual ~MIDIBLEInstance() = default;
    virtual void handleConnect(BLEConnectionHandle conn_handle) = 0;
    virtual void handleDisconnect(BLEConnectionHandle conn_handle) = 0;
    virtual void handleMTU(BLEConnectionHandle conn_handle, uint16_t mtu) = 0;
    virtual void handleSubscribe(BLEConnectionHandle conn_handle,
                                 BLECharacteristicHandle char_handle,
                                 bool notify) = 0;
    virtual void handleData(BLEConnectionHandle conn_handle,
                            BLEDataGenerator &&data,
                            BLEDataLifetime lifetime) = 0;
};
 
struct BLESettings {
    const char *device_name = "Control Surface MIDI";
    struct {
        uint16_t minimum = 0x000C;
        uint16_t maximum = 0x000C;
    } connection_interval {};
    bool initiate_security = false;
};
 
END_CS_NAMESPACE
 
#include "BLEAPI.ipp"