Advertisement.hxx

Go to the documentation of this file.

 
#ifndef _BLE_ADVERTISEMENT_HXX_
#define _BLE_ADVERTISEMENT_HXX_
 
#include "ble/Defs.hxx"
#include "utils/macros.h"
 
namespace ble
{
 
class Advertisement
{
public:
    static constexpr size_t MAX_DATA_PAYLOAD_SIZE = 31;
 
    static constexpr size_t MAX_SCAN_DATA_PAYLOAD_SIZE = 31;
 
    static constexpr size_t MAX_EXT_DATA_PAYLOAD_SIZE = 254;
 
    enum Field
    {
        DATA, 
        SCAN_DATA, 
    };
 
    enum class Flags : uint8_t
    {
        LE_LIMITED_DISC_MODE      = 0x01, 
        LE_GENERAL_DISC_MODE      = 0x02, 
        BR_EDR_NOT_SUPPORTED      = 0x04, 
        LE_BR_EDR_CONTROLLER      = 0x08, 
        LE_BR_EDR_HOST            = 0x10, 
        LE_ONLY_LIMITED_DISC_MODE = 0x05, 
        LE_ONLY_GENERAL_DISC_MODE = 0x06, 
    };
 
    Advertisement(bool extended = false)
        : extended_(extended)
    {
    }
 
    Advertisement(size_t data_reserve, size_t scan_data_reserve)
        : extended_(false)
    {
        if (data_reserve > MAX_DATA_PAYLOAD_SIZE)
        {
            data_reserve = MAX_DATA_PAYLOAD_SIZE;
        }
        if (scan_data_reserve > MAX_SCAN_DATA_PAYLOAD_SIZE)
        {
            scan_data_reserve = MAX_SCAN_DATA_PAYLOAD_SIZE;
        }
        data_.reserve(data_reserve);
        scanData_.reserve(scan_data_reserve);
    }
 
    Advertisement(size_t data_reserve, size_t dummy, bool extended)
        : extended_(extended)
    {
        size_t max =
            extended_ ? MAX_EXT_DATA_PAYLOAD_SIZE : MAX_DATA_PAYLOAD_SIZE;
        if (data_reserve > max)
        {
            data_reserve = max;
        }
        data_.reserve(data_reserve);
    }
 
    std::basic_string<uint8_t> concat_service_data_128(
        const uint8_t uuid[16], const void *buf, size_t size);
 
    std::basic_string<uint8_t> concat_service_data_128(
        const uint8_t uuid[16], std::basic_string<uint8_t> &buf)
    {
        return concat_service_data_128(uuid, buf.data(), buf.size());
    }
 
    int prepend(Field field, Defs::AdvType type, const void *buf, size_t size,
                bool clip = false);
 
    int prepend(Field field, Defs::AdvType type,
                std::basic_string<uint8_t> &buf, bool clip = false)
    {
        return prepend(field, type, buf.data(), buf.size(), clip);
    }
 
    int prepend_name(Field field, std::string &name)
    {
        int result = prepend(
            field, Defs::AdvType::NAME_COMPLETE, name.data(), name.size());
        if (result > 0)
        {
            return result;
        }
        return prepend(
            field, Defs::AdvType::NAME_SHORT, name.data(), name.size(), true);
    }
 
    int append(Field field, Defs::AdvType type, const void *buf, size_t size,
               bool clip = false);
 
    int append(Field field, Defs::AdvType type, std::basic_string<uint8_t> &buf,
               bool clip = false)
    {
        return append(field, type, buf.data(), buf.size(), clip);
    }
 
    int append_name(Field field, std::string &name)
    {
        int result = append(
            field, Defs::AdvType::NAME_COMPLETE, name.data(), name.size());
        if (result > 0)
        {
            return result;
        }
        return append(
            field, Defs::AdvType::NAME_SHORT, name.data(), name.size(), true);
    }
 
    int update(Field field, Defs::AdvType type, const void *buf, size_t size,
               unsigned instance = 1, bool exact_size = true,
               bool clip = false);
 
    int update(Field field, Defs::AdvType type, std::basic_string<uint8_t> &buf,
               unsigned instance = 1, bool exact_size = true,
               bool clip = false)
    {
        return update(
            field, type, buf.data(), buf.size(), instance, exact_size, clip);
    }
 
    bool is_extended()
    {
        return extended_;
    }
 
    uint8_t *get_data()
    {
        return (uint8_t*)data_.data();
    }
 
    size_t get_data_size()
    {
        return data_.size();
    }
 
    uint8_t *get_scan_data()
    {
        HASSERT(!extended_);
        return (uint8_t*)scanData_.data();
    }
 
    size_t get_scan_data_size()
    {
        return extended_ ? 0 : scanData_.size();
    }
 
#if defined(GTEST)
    std::basic_string<uint8_t> &test_get_data()
    {
        return data_;
    }
 
    std::basic_string<uint8_t> &test_get_scan_data()
    {
        return scanData_;
    }
#endif
 
private:
    std::basic_string<uint8_t> data_;
 
    std::basic_string<uint8_t> scanData_;
 
    bool extended_; 
};
 
} // namespace ble
 
#endif // _BLE_ADVERTISEMENT_HXX_