NimBLEAttValue.h

/*
 * Copyright 2020-2025 Ryan Powell <ryan@nable-embedded.io> and
 * esp-nimble-cpp, NimBLE-Arduino contributors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef NIMBLE_CPP_ATTVALUE_H
#define NIMBLE_CPP_ATTVALUE_H
 
#include "syscfg/syscfg.h"
#if CONFIG_BT_NIMBLE_ENABLED
 
# ifdef USING_NIMBLE_ARDUINO_HEADERS
#  include "nimble/nimble/include/nimble/nimble_npl.h"
# else
#  include "nimble/nimble_npl.h"
# endif
 
/* Enables the use of Arduino String class for attribute values */
# ifndef NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
#  define NIMBLE_CPP_ARDUINO_STRING_AVAILABLE (__has_include(<Arduino.h>))
# endif
 
# if NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
#  include <WString.h>
# endif
 
# include <string>
# include <vector>
# include <ctime>
# include <cstring>
# include <cstdint>
# include <atomic>
 
# ifndef MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
#  ifndef CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
#   define MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED 0
#  else
#   define MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED CONFIG_NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED
#  endif
# endif
 
# ifndef BLE_ATT_ATTR_MAX_LEN
#  define BLE_ATT_ATTR_MAX_LEN 512
# endif
 
# ifndef MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH
#  ifndef CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH
#   define MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH 20
#  else
#   define MYNEWT_VAL_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH CONFIG_NIMBLE_CPP_ATT_VALUE_INIT_LENGTH
#  endif
# endif
 
# if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_INIT_LENGTH) > BLE_ATT_ATTR_MAX_LEN
#  error NIMBLE_CPP_ATT_VALUE_INIT_LENGTH cannot be larger than 512 (BLE_ATT_ATTR_MAX_LEN)
# elif MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_INIT_LENGTH) < 1
#  error NIMBLE_CPP_ATT_VALUE_INIT_LENGTH cannot be less than 1; Range = 1 : 512
# endif
 
/* Used to determine if the type passed to a template has a data() and size() method. */
template <typename T, typename = void, typename = void>
struct Has_data_size : std::false_type {};
 
template <typename T>
struct Has_data_size<T, decltype(void(std::declval<T&>().data())), decltype(void(std::declval<T&>().size()))>
    : std::true_type {};
 
/* Used to determine if the type passed to a template has a c_str() and length() method. */
template <typename T, typename = void, typename = void>
struct Has_c_str_length : std::false_type {};
 
template <typename T>
struct Has_c_str_length<T, decltype(void(std::declval<T&>().c_str())), decltype(void(std::declval<T&>().length()))>
    : std::true_type {};
 
/* Used to determine if the type passed to a template has a value_type member (std::vector, std::array, std::string, etc.). */
template <typename T, typename = void>
struct Has_value_type : std::false_type {};
 
template <typename T>
struct Has_value_type<T, decltype(void(sizeof(typename T::value_type)))>
    : std::true_type {};
 
class NimBLEAttValue {
    uint8_t* m_attr_value{};
    uint16_t m_attr_max_len{};
    uint16_t m_attr_len{};
    uint16_t m_capacity{};
# if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
    time_t m_timestamp{};
# endif
    bool deepCopy(const NimBLEAttValue& source);
 
  public:
    class Lock {
        static ble_npl_mutex     m_mutex;
        static std::atomic<bool> m_initialized;
        static std::atomic<int>  m_activeCount;
        bool                     m_locked{false};
 
      public:
        Lock() {
            // Increment active count to signal that a constructor is running
            m_activeCount.fetch_add(1);
 
            if (m_initialized.load()) {
                m_locked = (ble_npl_mutex_pend(&m_mutex, BLE_NPL_TIME_FOREVER) == BLE_NPL_OK);
 
                // Post-lock check: If deinit flipped the flag while we were waiting in line,
                // we must abort, give it back, and act un-locked.
                if (!m_initialized.load() && m_locked) {
                    ble_npl_mutex_release(&m_mutex);
                    m_locked = false;
                }
            }
 
            // Decrement active count to signal that the constructor has finished processing
            m_activeCount.fetch_sub(1);
        }
 
        ~Lock() {
            if (m_locked) {
                ble_npl_mutex_release(&m_mutex);
            }
        }
 
        static bool init() {
            if (!m_initialized.load()) {
                if (ble_npl_mutex_init(&m_mutex) == BLE_NPL_OK) {
                    m_initialized.store(true);
                }
            }
            return m_initialized.load();
        }
 
        static void deinit() {
            if (m_initialized.load()) {
                // Prevent any new instances from acquiring the lock while we deinitialize
                m_initialized.store(false);
 
                // Wait for any active users to finish
                while (m_activeCount.load() > 0) {
                    ble_npl_time_delay(1);
                }
 
                // Acquire the mutex to ensure no other threads are holding it before deinitializing.
                if (ble_npl_mutex_pend(&m_mutex, BLE_NPL_TIME_FOREVER) == BLE_NPL_OK) {
                    // Deinitialize the mutex now that we have exclusive ownership and no active users.
                    ble_npl_mutex_deinit(&m_mutex);
                }
            }
        }
    };
 
    NimBLEAttValue(uint16_t init_len = MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_INIT_LENGTH), uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);
 
    NimBLEAttValue(const uint8_t* value, uint16_t len, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN);
 
    NimBLEAttValue(const char* value, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
        : NimBLEAttValue((uint8_t*)value, (uint16_t)strlen(value), max_len) {}
 
    NimBLEAttValue(std::initializer_list<uint8_t> list, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
        : NimBLEAttValue(list.begin(), list.size(), max_len) {}
 
    NimBLEAttValue(const std::string str, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
        : NimBLEAttValue(reinterpret_cast<const uint8_t*>(&str[0]), str.length(), max_len) {}
 
    NimBLEAttValue(const std::vector<uint8_t> vec, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
        : NimBLEAttValue(&vec[0], vec.size(), max_len) {}
 
# if NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
    NimBLEAttValue(const String str, uint16_t max_len = BLE_ATT_ATTR_MAX_LEN)
        : NimBLEAttValue(reinterpret_cast<const uint8_t*>(str.c_str()), str.length(), max_len) {}
# endif
 
    NimBLEAttValue(const NimBLEAttValue& source) { deepCopy(source); }
 
    NimBLEAttValue(NimBLEAttValue&& source) { *this = std::move(source); }
 
    ~NimBLEAttValue();
 
    uint16_t max_size() const { return m_attr_max_len; }
 
    uint16_t capacity() const { return m_capacity; }
 
    uint16_t length() const { return m_attr_len; }
 
    uint16_t size() const { return m_attr_len; }
 
    const uint8_t* data() const { return m_attr_value; }
 
    const char* c_str() const { return reinterpret_cast<const char*>(m_attr_value); }
 
    const uint8_t* begin() const { return m_attr_value; }
 
    const uint8_t* end() const { return m_attr_value + m_attr_len; }
 
# if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
    time_t getTimeStamp() const { return m_timestamp; }
 
    void setTimeStamp() { m_timestamp = time(nullptr); }
 
    void setTimeStamp(time_t t) { m_timestamp = t; }
# else
    time_t getTimeStamp() const { return 0; }
    void   setTimeStamp() {}
    void   setTimeStamp(time_t t) {}
# endif
 
    bool setValue(const uint8_t* value, uint16_t len);
 
    bool setValue(const char* s, uint16_t len = 0) {
        if (len == 0) {
            len = strlen(s);
        }
        return setValue(reinterpret_cast<const uint8_t*>(s), len);
    }
 
    const NimBLEAttValue& getValue(time_t* timestamp = nullptr) const {
        if (timestamp != nullptr) {
# if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
            *timestamp = m_timestamp;
# else
            *timestamp = 0;
# endif
        }
        return *this;
    }
 
    NimBLEAttValue& append(const uint8_t* value, uint16_t len);
 
    bool copyFrom(const NimBLEAttValue& source) { return deepCopy(source); }
 
    /*********************** Template Functions ************************/
 
# if __cplusplus < 201703L
    template <typename T>
#  ifdef _DOXYGEN_
    bool
#  else
    typename std::enable_if<std::is_array<T>::value && std::is_same<typename std::remove_extent<T>::type, char>::value, bool>::type
#  endif
    setValue(const T& s) {
        return setValue(reinterpret_cast<const uint8_t*>(s), strnlen(s, sizeof(T)));
    }
 
    template <typename T>
#  ifdef _DOXYGEN_
    bool
#  else
    typename std::enable_if<!std::is_pointer<T>::value && !Has_c_str_length<T>::value && !Has_data_size<T>::value &&
                                !(std::is_array<T>::value && std::is_same<typename std::remove_extent<T>::type, char>::value),
                            bool>::type
#  endif
    setValue(const T& v) {
        return setValue(reinterpret_cast<const uint8_t*>(&v), sizeof(T));
    }
 
    template <typename T>
#  ifdef _DOXYGEN_
    bool
#  else
    typename std::enable_if<Has_c_str_length<T>::value && !Has_data_size<T>::value, bool>::type
#  endif
    setValue(const T& s) {
        return setValue(reinterpret_cast<const uint8_t*>(s.c_str()), s.length());
    }
 
    template <typename T>
#  ifdef _DOXYGEN_
    bool
#  else
    typename std::enable_if<Has_data_size<T>::value && Has_value_type<T>::value, bool>::type
#  endif
    setValue(const T& v) {
        return setValue(
            reinterpret_cast<const uint8_t*>(v.data()),
            v.size() * sizeof(typename T::value_type)
        );
    }
 
    template <typename T>
#  ifdef _DOXYGEN_
    bool
#  else
    typename std::enable_if<Has_data_size<T>::value && !Has_value_type<T>::value, bool>::type
#  endif
    setValue(const T& v) {
        return setValue(reinterpret_cast<const uint8_t*>(v.data()), v.size());
    }
 
# else
    template <typename T>
    typename std::enable_if<!std::is_pointer<T>::value, bool>::type setValue(const T& s) {
        if constexpr (Has_data_size<T>::value) {
            if constexpr (Has_value_type<T>::value) {
                return setValue(reinterpret_cast<const uint8_t*>(s.data()), s.size() * sizeof(typename T::value_type));
            } else {
                return setValue(reinterpret_cast<const uint8_t*>(s.data()), s.size());
            }
        } else if constexpr (Has_c_str_length<T>::value) {
            return setValue(reinterpret_cast<const uint8_t*>(s.c_str()), s.length());
        } else if constexpr (std::is_array<T>::value && std::is_same<typename std::remove_extent<T>::type, char>::value) {
            return setValue(reinterpret_cast<const uint8_t*>(s), strnlen(s, sizeof(s)));
        } else {
            return setValue(reinterpret_cast<const uint8_t*>(&s), sizeof(s));
        }
    }
# endif
 
    template <typename T>
    T getValue(time_t* timestamp = nullptr, bool skipSizeCheck = false) const {
        Lock lock;
        if (timestamp != nullptr) {
# if MYNEWT_VAL(NIMBLE_CPP_ATT_VALUE_TIMESTAMP_ENABLED)
            *timestamp = m_timestamp;
# else
            *timestamp = 0;
# endif
        }
 
        if (!skipSizeCheck && size() < sizeof(T)) {
            return T();
        }
        return *(reinterpret_cast<const T*>(m_attr_value));
    }
 
    /*********************** Operators ************************/
 
    uint8_t operator[](int pos) const;
 
    operator std::vector<uint8_t>() const {
        Lock lock;
        return std::vector<uint8_t>(m_attr_value, m_attr_value + m_attr_len);
    }
 
    operator std::string() const {
        Lock lock;
        return std::string(reinterpret_cast<char*>(m_attr_value), m_attr_len);
    }
 
    operator const uint8_t*() const { return m_attr_value; }
 
    NimBLEAttValue& operator+=(const NimBLEAttValue& source) {
        Lock lock; // Recursive; keeps the source data and size consistent while appending
        if (&source == this) {
            // append() may reallocate the buffer, so append from a copy of our own data
            std::vector<uint8_t> copy(m_attr_value, m_attr_value + m_attr_len);
            return append(copy.data(), copy.size());
        }
        return append(source.data(), source.size());
    }
 
    NimBLEAttValue& operator=(const std::string& source) {
        setValue(reinterpret_cast<const uint8_t*>(&source[0]), source.size());
        return *this;
    }
 
    NimBLEAttValue& operator=(NimBLEAttValue&& source);
 
    NimBLEAttValue& operator=(const NimBLEAttValue& source);
 
    bool operator==(const NimBLEAttValue& source) const {
        Lock lock;
        return (m_attr_len == source.size()) ? memcmp(m_attr_value, source.data(), m_attr_len) == 0 : false;
    }
 
    bool operator!=(const NimBLEAttValue& source) const { return !(*this == source); }
 
# if NIMBLE_CPP_ARDUINO_STRING_AVAILABLE
    operator String() const {
        Lock lock;
        return String(reinterpret_cast<char*>(m_attr_value));
    }
# endif
};
 
#endif // CONFIG_BT_NIMBLE_ENABLED
#endif // NIMBLE_CPP_ATTVALUE_H_