NimBLEL2CAPChannel.h

//
// (C) Dr. Michael 'Mickey' Lauer <mickey@vanille-media.de>
//
 
#ifndef NIMBLE_CPP_L2CAPCHANNEL_H_
#define NIMBLE_CPP_L2CAPCHANNEL_H_
 
#include "nimconfig.h"
#if CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_L2CAP_COC_MAX_NUM
 
# include "inttypes.h"
# if defined(CONFIG_NIMBLE_CPP_IDF)
#  include "host/ble_l2cap.h"
#  include "os/os_mbuf.h"
# else
#  include "nimble/nimble/host/include/host/ble_l2cap.h"
#  include "nimble/porting/nimble/include/os/os_mbuf.h"
# endif
 
/****  FIX COMPILATION ****/
# undef min
# undef max
/**************************/
 
# include <vector>
# include <atomic>
 
class NimBLEClient;
class NimBLEL2CAPChannelCallbacks;
struct NimBLETaskData;
 
class NimBLEL2CAPChannel {
  public:
    static NimBLEL2CAPChannel* connect(NimBLEClient* client, uint16_t psm, uint16_t mtu, NimBLEL2CAPChannelCallbacks* callbacks);
 
    bool write(const std::vector<uint8_t>& bytes);
 
    bool isConnected() const { return !!channel; }
 
  protected:
    NimBLEL2CAPChannel(uint16_t psm, uint16_t mtu, NimBLEL2CAPChannelCallbacks* callbacks);
    ~NimBLEL2CAPChannel();
 
    int handleConnectionEvent(struct ble_l2cap_event* event);
    int handleAcceptEvent(struct ble_l2cap_event* event);
    int handleDataReceivedEvent(struct ble_l2cap_event* event);
    int handleTxUnstalledEvent(struct ble_l2cap_event* event);
    int handleDisconnectionEvent(struct ble_l2cap_event* event);
 
  private:
    friend class NimBLEL2CAPServer;
    static constexpr const char* LOG_TAG = "NimBLEL2CAPChannel";
 
    const uint16_t               psm; // PSM of the channel
    const uint16_t               mtu; // The requested (local) MTU of the channel, might be larger than negotiated MTU
    struct ble_l2cap_chan*       channel = nullptr;
    NimBLEL2CAPChannelCallbacks* callbacks;
    uint8_t*                     receiveBuffer = nullptr; // buffers a full (local) MTU
 
    // NimBLE memory pool
    void*               _coc_memory = nullptr;
    struct os_mempool   _coc_mempool;
    struct os_mbuf_pool _coc_mbuf_pool;
 
    // Runtime handling
    std::atomic<bool> stalled{false};
    NimBLETaskData*   m_pTaskData{nullptr};
 
    // Allocate / deallocate NimBLE memory pool
    bool setupMemPool();
    void teardownMemPool();
 
    // Writes data up to the size of the negotiated MTU to the channel.
    int writeFragment(std::vector<uint8_t>::const_iterator begin, std::vector<uint8_t>::const_iterator end);
 
    // L2CAP event handler
    static int handleL2capEvent(struct ble_l2cap_event* event, void* arg);
};
 
class NimBLEL2CAPChannelCallbacks {
  public:
    NimBLEL2CAPChannelCallbacks()          = default;
    virtual ~NimBLEL2CAPChannelCallbacks() = default;
 
    virtual bool shouldAcceptConnection(NimBLEL2CAPChannel* channel) { return true; }
    virtual void onConnect(NimBLEL2CAPChannel* channel, uint16_t negotiatedMTU) {};
    virtual void onRead(NimBLEL2CAPChannel* channel, std::vector<uint8_t>& data) {};
    virtual void onDisconnect(NimBLEL2CAPChannel* channel) {};
};
 
#endif // CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_L2CAP_COC_MAX_NUM
#endif // NIMBLE_CPP_L2CAPCHANNEL_H_