cs_CharacteristicBase.h

Go to the documentation of this file.

 
#pragma once
 
#include <ble/cs_Nordic.h>
#include <ble/cs_Service.h>
#include <common/cs_Types.h>
#include <structs/cs_CharacteristicStructs.h>
#include <third/std/function.h>
 
// This should depend on the MTU instead.
#define MAX_NOTIFICATION_LEN 20
 
class Service;
class CharacteristicBase;
 
typedef function<void(CharacteristicEventType, CharacteristicBase*, EncryptionAccessLevel)> characteristic_callback_t;
 
class CharacteristicBase {
public:
    CharacteristicBase();
 
    virtual ~CharacteristicBase() {}
 
    cs_ret_code_t setName(const char* const name);
 
    cs_ret_code_t setUuid(uint16_t uuid);
 
    cs_ret_code_t setConfig(const characteristic_config_t& config);
 
    cs_ret_code_t setEventHandler(const characteristic_callback_t& closure);
 
    cs_ret_code_t setValueBuffer(buffer_ptr_t buffer, cs_buffer_size_t size);
 
    cs_ret_code_t setInitialValueLength(cs_buffer_size_t size);
 
    cs_ret_code_t init(Service* svc);
 
    cs_ret_code_t updateValue(uint16_t length);
 
    cs_ret_code_t notify(uint16_t length = 0, uint16_t offset = 0);
 
    cs_data_t getValue();
 
    uint16_t getValueHandle();
 
    uint16_t getCccdHandle();
 
    bool isSubscribedForNotifications();
 
protected:
    friend Service;
 
    void onWrite(uint16_t length);
 
    void onNotificationDone();
 
    void onCccdWrite(const uint8_t* data, uint16_t size);
 
    void onConnect();
 
    void onDisconnect();
 
private:
    struct __attribute__((__packed__)) chunked_notification_t {
        uint8_t partNr;
        uint8_t data[MAX_NOTIFICATION_LEN - sizeof(partNr)];
    };
 
    bool _initialized                   = false;
 
    const char* _name                   = nullptr;
 
    uint16_t _uuid                      = 0;
 
    characteristic_config_t _config     = characteristic_config_t();
 
    characteristic_callback_t _callback = {};
 
    ble_gatts_char_handles_t _handles   = ble_gatts_char_handles_t();
 
    Service* _service                   = nullptr;
 
    cs_data_t _buffer                   = {};
 
    uint16_t _valueLength               = 0;
 
    cs_data_t _encryptedBuffer          = {};
 
    uint16_t _encryptedValueLength      = 0;
 
    bool _notificationPending           = false;
 
    uint16_t _notificationOffset        = 0;
 
    bool _subscribedForNotifications    = false;
 
    bool _subscribedForIndications      = false;
 
    cs_ret_code_t initEncryptedBuffer();
 
    void deinitEncryptedBuffer();
 
    cs_ret_code_t setGattValue();
 
    cs_ret_code_t notifyMultipart();
 
    uint16_t getGattValueMaxLength();
 
    uint16_t getGattValueLength();
 
    uint8_t* getGattValue();
 
    bool isEncrypted();
};