ThingsBoard.h

Go to the documentation of this file.

#ifndef ThingsBoard_h
#define ThingsBoard_h
 
// Local includes.
#include "Constants.h"
#include "IAPI_Implementation.h"
#include "IMQTT_Client.h"
#include "DefaultLogger.h"
#include "Telemetry.h"
 
// Library includes.
#if THINGSBOARD_ENABLE_STREAM_UTILS
#include <StreamUtils.h>
#endif // THINGSBOARD_ENABLE_STREAM_UTILS
 
 
uint16_t constexpr DEFAULT_MQTT_PORT = 1883U;
char constexpr PROV_ACCESS_TOKEN[] = "provision";
// Log messages.
char constexpr UNABLE_TO_DE_SERIALIZE_JSON[] = "Unable to de-serialize received json data with error (DeserializationError::%s)";
char constexpr INVALID_BUFFER_SIZE[] = "Send buffer size (%u) to small for the given payloads size (%u), increase with Set_Buffer_Size accordingly or install the StreamUtils library";
char constexpr UNABLE_TO_ALLOCATE_BUFFER[] = "Allocating memory for the internal MQTT buffer failed";
char constexpr MAX_ENDPOINTS_AMOUNT_TEMPLATE_NAME[] = "MaxEndpointsAmount";
#if THINGSBOARD_ENABLE_DYNAMIC
char constexpr MAXIMUM_RESPONSE_EXCEEDED[] = "Prevented allocation on the heap (%u) for JsonDocument. Discarding message that is bigger than maximum response size (%u)";
char constexpr HEAP_ALLOCATION_FAILED[] = "Failed allocating required size (%u) for JsonDocument. Ensure there is enough heap memory left";
#else
char constexpr API_SUBSCRIPTIONS[] = "API implementation";
#endif // THINGSBOARD_ENABLE_DYNAMIC
#if THINGSBOARD_ENABLE_DEBUG
char constexpr RECEIVE_MESSAGE[] = "Received (%u) bytes of data from server over topic (%s)";
char constexpr ALLOCATING_JSON[] = "Allocated internal JsonDocument for MQTT server response with size (%u)";
char constexpr SEND_MESSAGE[] = "Sending data to server over topic (%s) with data (%s)";
char constexpr SEND_SERIALIZED[] = "Hidden, because json data is bigger than buffer, therefore showing in console is skipped";
#endif // THINGSBOARD_ENABLE_DEBUG
// Claim topics.
char constexpr CLAIM_TOPIC[] = "v1/devices/me/claim";
// Claim data keys.
char constexpr SECRET_KEY[] = "secretKey";
char constexpr DURATION_KEY[] = "durationMs";
 
 
#if THINGSBOARD_ENABLE_DYNAMIC
template <typename Logger = DefaultLogger>
#else
template<size_t MaxResponse = DEFAULT_RESPONSE_AMOUNT, size_t MaxEndpointsAmount = DEFAULT_ENDPOINT_AMOUNT, typename Logger = DefaultLogger>
#endif // THINGSBOARD_ENABLE_DYNAMIC
class ThingsBoardSized {
  public:
    template<typename... Args>
#if THINGSBOARD_ENABLE_DYNAMIC
#if THINGSBOARD_ENABLE_STREAM_UTILS
    ThingsBoardSized(IMQTT_Client & client, uint16_t receive_buffer_size = DEFAULT_PAYLOAD_SIZE, uint16_t send_buffer_size = DEFAULT_PAYLOAD_SIZE, size_t const & max_stack_size = DEFAULT_MAX_STACK_SIZE, size_t const & buffering_size = DEFAULT_BUFFERING_SIZE, size_t const & max_response_size = DEFAULT_MAX_RESPONSE_SIZE, Args const &... args)
#else
    ThingsBoardSized(IMQTT_Client & client, uint16_t receive_buffer_size = DEFAULT_PAYLOAD_SIZE, uint16_t send_buffer_size = DEFAULT_PAYLOAD_SIZE, size_t const & max_stack_size = DEFAULT_MAX_STACK_SIZE, size_t const & max_response_size = DEFAULT_MAX_RESPONSE_SIZE, Args const &... args)
#endif // THINGSBOARD_ENABLE_STREAM_UTILS
#else
#if THINGSBOARD_ENABLE_STREAM_UTILS
    ThingsBoardSized(IMQTT_Client & client, uint16_t receive_buffer_size = DEFAULT_PAYLOAD_SIZE, uint16_t send_buffer_size = DEFAULT_PAYLOAD_SIZE, size_t const & max_stack_size = DEFAULT_MAX_STACK_SIZE, size_t const & buffering_size = DEFAULT_BUFFERING_SIZE, Args const &... args)
#else
    ThingsBoardSized(IMQTT_Client & client, uint16_t receive_buffer_size = DEFAULT_PAYLOAD_SIZE, uint16_t send_buffer_size = DEFAULT_PAYLOAD_SIZE, size_t const & max_stack_size = DEFAULT_MAX_STACK_SIZE, Args const &... args)
#endif // THINGSBOARD_ENABLE_STREAM_UTILS
#endif // THINGSBOARD_ENABLE_DYNAMIC
      : m_client(client)
      , m_max_stack(max_stack_size)
#if THINGSBOARD_ENABLE_STREAM_UTILS
      , m_buffering_size(buffering_size)
#endif // THINGSBOARD_ENABLE_STREAM_UTILS
#if THINGSBOARD_ENABLE_DYNAMIC
       , m_max_response_size(max_response_size)
#endif // THINGSBOARD_ENABLE_DYNAMIC
      , m_api_implementations(args...)
    {
        for (auto & api : m_api_implementations) {
            if (api == nullptr) {
                continue;
            }
#if THINGSBOARD_ENABLE_STL
            api->Set_Client_Callbacks(std::bind(&ThingsBoardSized::Subscribe_API_Implementation, this, std::placeholders::_1), std::bind(&ThingsBoardSized::Send_Json, this, std::placeholders::_1, std::placeholders::_2), std::bind(&ThingsBoardSized::Send_Json_String, this, std::placeholders::_1, std::placeholders::_2), std::bind(&ThingsBoardSized::Subscribe_Topic, this, std::placeholders::_1), std::bind(&ThingsBoardSized::Unsubscribe_Topic, this, std::placeholders::_1), std::bind(&ThingsBoardSized::Get_Receive_Buffer_Size, this), std::bind(&ThingsBoardSized::Get_Send_Buffer_Size, this), std::bind(&ThingsBoardSized::Set_Buffer_Size, this, std::placeholders::_1, std::placeholders::_2), std::bind(&ThingsBoardSized::Get_Last_Request_ID, this));
#else
            api->Set_Client_Callbacks(ThingsBoardSized::Static_Subscribe_Implementation, ThingsBoardSized::Static_Send_Json, ThingsBoardSized::Static_Send_Json_String, ThingsBoardSized::Static_Subscribe_Topic, ThingsBoardSized::Static_Unsubscribe_Topic, ThingsBoardSized::Static_Get_Receive_Buffer_Size, ThingsBoardSized::Static_Get_Send_Buffer_Size, ThingsBoardSized::Static_Set_Buffer_Size, ThingsBoardSized::Static_Get_Last_Request_ID);
#endif // THINGSBOARD_ENABLE_STL
            api->Initialize();
        }
        (void)Set_Buffer_Size(receive_buffer_size, send_buffer_size);
        // Initialize callback.
#if THINGSBOARD_ENABLE_STL
        m_client.set_data_callback(std::bind(&ThingsBoardSized::On_MQTT_Message, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
        m_client.set_connect_callback(std::bind(&ThingsBoardSized::Resubscribe_Permanent_Subscriptionss, this));
#else
        m_client.set_data_callback(ThingsBoardSized::On_Static_MQTT_Message);
        m_client.set_connect_callback(ThingsBoardSized::Static_MQTT_Connect);
        m_subscribedInstance = this;
#endif // THINGSBOARD_ENABLE_STL
    }
 
    IMQTT_Client & Get_Client() {
        return m_client;
    }
 
    void Set_Maximum_Stack_Size(size_t const & max_stack_size) {
        m_max_stack = max_stack_size;
    }
 
    size_t const & Get_Maximum_Stack_Size() const {
        return m_max_stack;
    }
 
#if THINGSBOARD_ENABLE_STREAM_UTILS
    size_t const & Get_Buffering_Size() const {
      return m_buffering_size;
    }
 
    void Set_Buffering_Size(size_t const & buffering_size) {
        m_buffering_size = buffering_size;
    }
#endif // THINGSBOARD_ENABLE_STREAM_UTILS
 
#if THINGSBOARD_ENABLE_DYNAMIC
    void Set_Max_Response_Size(size_t const & max_response_size) {
        m_max_response_size = max_response_size;
    }
 
    size_t const & Get_Max_Response_Size() {
        return m_max_response_size;
    }
#endif // THINGSBOARD_ENABLE_DYNAMIC
 
    bool Set_Buffer_Size(uint16_t receive_buffer_size, uint16_t send_buffer_size) {
        bool const result = m_client.set_buffer_size(receive_buffer_size, send_buffer_size);
        if (!result) {
            Logger::printfln(UNABLE_TO_ALLOCATE_BUFFER);
        }
        return result;
    }
 
    uint16_t Get_Receive_Buffer_Size() {
        return m_client.get_receive_buffer_size();
    }
 
    uint16_t Get_Send_Buffer_Size() {
        return m_client.get_send_buffer_size();
    }
 
    void Cleanup_Subscriptions() {
        for (auto & api : m_api_implementations) {
            if (api == nullptr) {
                continue;
            }
            // Results are ignored, because the important part of clearing internal data structures always succeeds
            (void)api->Unsubscribe();
        }
    }
 
    bool connect(char const * host, char const * access_token = PROV_ACCESS_TOKEN, uint16_t port = DEFAULT_MQTT_PORT, char const * client_id = nullptr, char const * password = nullptr) {
        if (host == nullptr) {
            return false;
        }
        m_client.set_server(host, port);
        return Connect_To_Host(access_token, Helper::String_IsNull_Or_Empty(client_id) ? access_token : client_id, Helper::String_IsNull_Or_Empty(password) ? nullptr : password);
    }
 
    void disconnect() {
        m_client.disconnect();
    }
 
    bool connected() {
        return m_client.connected();
    }
 
    MQTT_Connection_State Get_Connection_State() {
        return m_client.get_connection_state();
    }
 
    MQTT_Connection_Error Get_Last_Connection_Error() {
        return m_client.get_last_connection_error();
    }
 
    void Subscribe_Connection_State_Changed_Callback(Callback<void, MQTT_Connection_State, MQTT_Connection_Error>::function callback) {
        m_client.subscribe_connection_state_changed_callback(callback);
    }
 
    bool loop() {
#if !THINGSBOARD_USE_ESP_TIMER
        for (auto & api : m_api_implementations) {
            if (api == nullptr) {
                continue;
            }
            api->loop();
        }
#endif // !THINGSBOARD_USE_ESP_TIMER
        return m_client.loop();
    }
 
    bool Send_Json(char const * topic, JsonDocument const & source) {
        // Check if allocating needed memory failed when trying to create the JsonDocument,
        // if it did the isNull() method will return true. See https://arduinojson.org/v6/api/jsonvariant/isnull/ for more information
        if (source.isNull()) {
            Logger::printfln(UNABLE_TO_ALLOCATE_JSON);
            return false;
        }
        // Check if inserting any of the internal values failed because the JsonDocument was too small,
        // if it did the overflowed() method will return true. See https://arduinojson.org/v6/api/jsondocument/overflowed/ for more information
        if (source.overflowed()) {
            Logger::printfln(JSON_SIZE_TO_SMALL);
            return false;
        }
        bool result = false;
 
        size_t const json_size = Helper::Measure_Json(source);
#if THINGSBOARD_ENABLE_STREAM_UTILS
        // Check if the size of the given message would be too big for the actual client,
        // if it is utilize the serialize json work around, so that the internal client buffer can be circumvented
        if (json_size > m_client.get_send_buffer_size())  {
#if THINGSBOARD_ENABLE_DEBUG
            Logger::printfln(SEND_MESSAGE, topic, SEND_SERIALIZED);
#endif // THINGSBOARD_ENABLE_DEBUG
            result = Serialize_Json(topic, source, json_size - 1);
        }
        else
#endif // THINGSBOARD_ENABLE_STREAM_UTILS
        if (json_size > Get_Maximum_Stack_Size()) {
            char* json = new char[json_size]();
            if (serializeJson(source, json, json_size) < json_size - 1) {
                Logger::printfln(UNABLE_TO_SERIALIZE_JSON);
            }
            else {
                result = Send_Json_String(topic, json);
            }
            delete[] json;
            json = nullptr;
        }
        else {
            char json[json_size] = {};
            if (serializeJson(source, json, json_size) < json_size - 1) {
                Logger::printfln(UNABLE_TO_SERIALIZE_JSON);
                return result;
            }
            result = Send_Json_String(topic, json);
        }
 
        return result;
    }
 
    bool Send_Json_String(char const * topic, char const * json) {
        if (json == nullptr) {
            return false;
        }
 
        uint16_t current_send_buffer_size = m_client.get_send_buffer_size();
        auto const json_size = strlen(json);
 
        if (current_send_buffer_size < json_size) {
            Logger::printfln(INVALID_BUFFER_SIZE, current_send_buffer_size, json_size);
            return false;
        }
 
#if THINGSBOARD_ENABLE_DEBUG
        Logger::printfln(SEND_MESSAGE, topic, json);
#endif // THINGSBOARD_ENABLE_DEBUG
        return m_client.publish(topic, reinterpret_cast<uint8_t const *>(json), json_size);
    }
 
    void Subscribe_API_Implementation(IAPI_Implementation & api) {
#if !THINGSBOARD_ENABLE_DYNAMIC
        if (m_api_implementations.size() + 1 > m_api_implementations.capacity()) {
            Logger::printfln(MAX_SUBSCRIPTIONS_EXCEEDED, API_SUBSCRIPTIONS, MAX_ENDPOINTS_AMOUNT_TEMPLATE_NAME);
            return;
        }
#endif // !THINGSBOARD_ENABLE_DYNAMIC
#if THINGSBOARD_ENABLE_STL
        api.Set_Client_Callbacks(std::bind(&ThingsBoardSized::Subscribe_API_Implementation, this, std::placeholders::_1), std::bind(&ThingsBoardSized::Send_Json, this, std::placeholders::_1, std::placeholders::_2), std::bind(&ThingsBoardSized::Send_Json_String, this, std::placeholders::_1, std::placeholders::_2), std::bind(&ThingsBoardSized::Subscribe_Topic, this, std::placeholders::_1), std::bind(&ThingsBoardSized::Unsubscribe_Topic, this, std::placeholders::_1), std::bind(&ThingsBoardSized::Get_Receive_Buffer_Size, this), std::bind(&ThingsBoardSized::Get_Send_Buffer_Size, this), std::bind(&ThingsBoardSized::Set_Buffer_Size, this, std::placeholders::_1, std::placeholders::_2), std::bind(&ThingsBoardSized::Get_Last_Request_ID, this));
#else
        api.Set_Client_Callbacks(ThingsBoardSized::Static_Subscribe_Implementation, ThingsBoardSized::Static_Send_Json, ThingsBoardSized::Static_Send_Json_String, ThingsBoardSized::Static_Subscribe_Topic, ThingsBoardSized::Static_Unsubscribe_Topic, ThingsBoardSized::Static_Get_Receive_Buffer_Size, ThingsBoardSized::Static_Get_Send_Buffer_Size, ThingsBoardSized::Static_Set_Buffer_Size, ThingsBoardSized::Static_Get_Last_Request_ID);
#endif // THINGSBOARD_ENABLE_STL
        api.Initialize();
        m_api_implementations.push_back(&api);
    }
 
    template <typename InputIterator>
    void Subscribe_API_Implementations(InputIterator const & first, InputIterator const & last) {
#if !THINGSBOARD_ENABLE_DYNAMIC
        size_t const size = Helper::distance(first, last);
        if (m_api_implementations.size() + size > m_api_implementations.capacity()) {
            Logger::printfln(MAX_SUBSCRIPTIONS_EXCEEDED, API_SUBSCRIPTIONS, MAX_ENDPOINTS_AMOUNT_TEMPLATE_NAME);
            return;
        }
#endif // !THINGSBOARD_ENABLE_DYNAMIC
        for (auto it = first; it != last; ++it) {
            auto & api = *it;
            if (api == nullptr) {
                continue;
            }
#if THINGSBOARD_ENABLE_STL
            api->Set_Client_Callbacks(std::bind(&ThingsBoardSized::Subscribe_API_Implementation, this, std::placeholders::_1), std::bind(&ThingsBoardSized::Send_Json, this, std::placeholders::_1, std::placeholders::_2), std::bind(&ThingsBoardSized::Send_Json_String, this, std::placeholders::_1, std::placeholders::_2), std::bind(&ThingsBoardSized::Subscribe_Topic, this, std::placeholders::_1), std::bind(&ThingsBoardSized::Unsubscribe_Topic, this, std::placeholders::_1), std::bind(&ThingsBoardSized::Get_Receive_Buffer_Size, this), std::bind(&ThingsBoardSized::Get_Send_Buffer_Size, this), std::bind(&ThingsBoardSized::Set_Buffer_Size, this, std::placeholders::_1, std::placeholders::_2), std::bind(&ThingsBoardSized::Get_Last_Request_ID, this));
#else
            api->Set_Client_Callbacks(ThingsBoardSized::Static_Subscribe_Implementation, ThingsBoardSized::Static_Send_Json, ThingsBoardSized::Static_Send_Json_String, ThingsBoardSized::Static_Subscribe_Topic, ThingsBoardSized::Static_Unsubscribe_Topic, ThingsBoardSized::Static_Get_Receive_Buffer_Size, ThingsBoardSized::Static_Get_Send_Buffer_Size, ThingsBoardSized::Static_Set_Buffer_Size, ThingsBoardSized::Static_Get_Last_Request_ID);
#endif // THINGSBOARD_ENABLE_STL
            api->Initialize();
        }
        m_api_implementations.insert(m_api_implementations.end(), first, last);
    }
 
    //----------------------------------------------------------------------------
    // Claiming API
 
    bool Claim_Request(size_t const & duration_ms, char const * secret_key = nullptr) {
        StaticJsonDocument<JSON_OBJECT_SIZE(2)> request_buffer;
 
        if (!Helper::String_IsNull_Or_Empty(secret_key)) {
            request_buffer[SECRET_KEY] = secret_key;
        }
        request_buffer[DURATION_KEY] = duration_ms;
        return Send_Json(CLAIM_TOPIC, request_buffer);
    }
 
    //----------------------------------------------------------------------------
    // Telemetry API
 
    template<typename T>
    bool Send_Telemetry_Data(char const * key, T const & value) {
        return Send_Key_Value_Pair(key, value);
    }
 
#if THINGSBOARD_ENABLE_DYNAMIC
    template<typename InputIterator>
#else
    template<size_t MaxKeyValuePairAmount, typename InputIterator>
#endif // THINGSBOARD_ENABLE_DYNAMIC
    bool Send_Telemetry(InputIterator const & first, InputIterator const & last) {
#if THINGSBOARD_ENABLE_DYNAMIC
        return Send_Data_Array(first, last, true);
#else
        return Send_Data_Array<MaxKeyValuePairAmount>(first, last, true);
#endif // THINGSBOARD_ENABLE_DYNAMIC
    }
 
    bool Send_Telemetry_String(char const * json) {
        return Send_Json_String(TELEMETRY_TOPIC, json);
    }
 
    bool Send_Telemetry_Json(JsonDocument const & source) {
        return Send_Json(TELEMETRY_TOPIC, source);
    }
 
    //----------------------------------------------------------------------------
    // Attribute API
 
    template<typename T>
    bool Send_Attribute_Data(char const * key, T const & value) {
        return Send_Key_Value_Pair(key, value, false);
    }
 
#if THINGSBOARD_ENABLE_DYNAMIC
    template<typename InputIterator>
#else
    template<size_t MaxKeyValuePairAmount, typename InputIterator>
#endif // THINGSBOARD_ENABLE_DYNAMIC
    bool Send_Attributes(InputIterator const & first, InputIterator const & last) {
#if THINGSBOARD_ENABLE_DYNAMIC
        return Send_Data_Array(first, last, false);
#else
        return Send_Data_Array<MaxKeyValuePairAmount>(first, last, false);
#endif // THINGSBOARD_ENABLE_DYNAMIC
    }
 
    bool Send_Attribute_String(char const * json) {
        return Send_Json_String(ATTRIBUTE_TOPIC, json);
    }
 
    bool Send_Attribute_Json(JsonDocument const & source) {
        return Send_Json(ATTRIBUTE_TOPIC, source);
    }
 
  private:
#if THINGSBOARD_ENABLE_DYNAMIC
    using IAPI_Container = Container<IAPI_Implementation *>;
#else
    using IAPI_Container = Container<IAPI_Implementation *, MaxEndpointsAmount>;
#endif // THINGSBOARD_ENABLE_DYNAMIC
 
#if THINGSBOARD_ENABLE_STREAM_UTILS
    bool Serialize_Json(char const * topic, JsonDocument const & source) {
        size_t const json_size = Helper::Measure_Json(source);
        if (!m_client.begin_publish(topic, json_size - 1)) {
            Logger::printfln(UNABLE_TO_SERIALIZE_JSON);
            return false;
        }
        BufferingPrint buffered_print(m_client, Get_Buffering_Size());
        auto const bytes_serialized = serializeJson(source, buffered_print);
        if (bytes_serialized < json_size - 1) {
            Logger::printfln(UNABLE_TO_SERIALIZE_JSON);
            return false;
        }
        buffered_print.flush();
        return m_client.end_publish();
    }
#endif // THINGSBOARD_ENABLE_STREAM_UTILS
 
    bool Subscribe_Topic(char const * topic) {
        return m_client.subscribe(topic);
    }
 
    bool Unsubscribe_Topic(char const * topic) {
        return m_client.unsubscribe(topic);
    }
 
    size_t * Get_Last_Request_ID() {
        return &m_request_id;
    }
 
    bool Connect_To_Host(char const * access_token, char const * client_id, char const * password) {
        bool const connection_result = m_client.connect(client_id, access_token, password);
        if (!connection_result) {
            Logger::printfln(CONNECT_FAILED);
        }
        return connection_result;
    }
 
    void Resubscribe_Permanent_Subscriptionss() {
        for (auto & api : m_api_implementations) {
            if (api == nullptr) {
                continue;
            }
            // Results are ignored, because the important part of clearing internal data structures always succeeds
            (void)api->Resubscribe_Permanent_Subscriptions();
        }
    }
 
    template<typename T>
    bool Send_Key_Value_Pair(char const * key, T const & value, bool telemetry = true) {
        const Telemetry t(key, value);
        if (t.IsEmpty()) {
            return false;
        }
 
        StaticJsonDocument<JSON_OBJECT_SIZE(1)> json_buffer;
        if (!t.SerializeKeyValue(json_buffer)) {
            Logger::printfln(UNABLE_TO_SERIALIZE);
            return false;
        }
        return telemetry ? Send_Telemetry_Json(json_buffer) : Send_Attribute_Json(json_buffer);
    }
 
#if THINGSBOARD_ENABLE_DYNAMIC
    template<typename InputIterator>
#else
    template<size_t MaxKeyValuePairAmount, typename InputIterator>
#endif // THINGSBOARD_ENABLE_DYNAMIC
    bool Send_Data_Array(InputIterator const & first, InputIterator const & last, bool telemetry) {
        auto const size = Helper::distance(first, last);
#if THINGSBOARD_ENABLE_DYNAMIC
        // char const * are stored as only a pointer inside the JsonDocument --> zero copy, meaning the size for the strings is 0 bytes.
        // Data structure size, therefore only depends on the amount of key value pairs passed.
        // See https://arduinojson.org/v6/assistant/ for more information on the needed size for the JsonDocument
        TBJsonDocument json_buffer(JSON_OBJECT_SIZE(size));
#else
        if (size > MaxKeyValuePairAmount) {
            Logger::printfln(TOO_MANY_JSON_FIELDS, size, "MaxKeyValuePairAmount", MaxKeyValuePairAmount);
            return false;
        }
        StaticJsonDocument<JSON_OBJECT_SIZE(MaxKeyValuePairAmount)> json_buffer;
#endif // THINGSBOARD_ENABLE_DYNAMIC
 
#if THINGSBOARD_ENABLE_STL
        if (std::any_of(first, last, [&json_buffer](Telemetry const & data) { return !data.SerializeKeyValue(json_buffer); })) {
            Logger::printfln(UNABLE_TO_SERIALIZE);
            return false;
        }
#else
        for (auto it = first; it != last; ++it) {
            auto const & data = *it;
            if (!data.SerializeKeyValue(json_buffer)) {
                Logger::printfln(UNABLE_TO_SERIALIZE);
                return false;
            }
        }
#endif // THINGSBOARD_ENABLE_STL
        return telemetry ? Send_Telemetry_Json(json_buffer) : Send_Attribute_Json(json_buffer);
    }
 
    void On_MQTT_Message(char * topic, uint8_t * payload, unsigned int length) {
#if THINGSBOARD_ENABLE_DEBUG
        Logger::printfln(RECEIVE_MESSAGE, length, topic);
#endif // THINGSBOARD_ENABLE_DEBUG
 
#if THINGSBOARD_ENABLE_STL
#if THINGSBOARD_ENABLE_CXX20
        auto filtered_raw_api_implementations = m_api_implementations | std::views::filter([&topic](IAPI_Implementation const * api) {
#else
        IAPI_Container filtered_raw_api_implementations = {};
        std::copy_if(m_api_implementations.begin(), m_api_implementations.end(), std::back_inserter(filtered_raw_api_implementations), [&topic](IAPI_Implementation const * api) {
#endif // THINGSBOARD_ENABLE_CXX20
            return (api != nullptr && api->Get_Process_Type() == API_Process_Type::RAW && api->Is_Response_Topic_Matching(topic));
        });
 
        for (auto & api : filtered_raw_api_implementations) {
            api->Process_Response(topic, payload, length);
        }
 
        // If the filtered api implementations was not emtpy it means the response was processed as its raw bytes representation atleast once,
        // and because we interpreted it as raw bytes instead of json, we skip the further processing of those raw bytes as json.
        // We do that because the received response is in that case not even valid json in the first place and would therefore simply fail deserialization
        if (!filtered_raw_api_implementations.empty()) {
            return;
        }
#else
        bool processed_response_as_raw = false;
        for (auto & api : m_api_implementations) {
            if (api == nullptr || api->Get_Process_Type() != API_Process_Type::RAW || !api->Is_Response_Topic_Matching(topic)) {
                continue;
            }
            api->Process_Response(topic, payload, length);
            processed_response_as_raw = true;
        }
 
        if (processed_response_as_raw) {
            return;
        }
#endif // THINGSBOARD_ENABLE_STL
 
        // Calculate size with the total amount of commas, always denotes the end of a key-value pair besides for the last element in an array or in an object where the comma is not permitted,
        // therfore we have to add the space for another key-value pair for all the occurences of thoose symbols as well
        auto const size = Helper::Calculate_Symbol_Occurences(payload, ',', length) + Helper::Calculate_Symbol_Occurences(payload, '{', length) + Helper::Calculate_Symbol_Occurences(payload, '[', length);
#if THINGSBOARD_ENABLE_DYNAMIC
        // Buffer that we deserialize is writeable and not read only and therefore stored as a pointer inside the JsonDocument --> zero copy, meaning the size for the received payload is 0 bytes.
        // Data structure size, therefore only depends on the amount of key value pairs received.
        // See https://arduinojson.org/v6/assistant/ for more information on the needed size for the JsonDocument
        auto const document_size = JSON_OBJECT_SIZE(size);
        auto const & max_response_size = Get_Max_Response_Size();
        if (max_response_size != 0U && document_size > max_response_size) {
            Logger::printfln(MAXIMUM_RESPONSE_EXCEEDED, document_size, max_response_size);
            return;
        }
        TBJsonDocument json_buffer(document_size);
        // Because we calcualte the allocation dynamically fromt he payload, which is user input, it could theoretically be malicious ({ "malicious" : "{{{{{{{{{..."}) and contain a lot of the symbols used to calculate the size.
        // But if that is the case adn the allocation still succeeds we delete the allocated memory relatively fast again so it shouldn't be a problem and if the allocation fails we simply return at this point with an appropriate error message
        if (json_buffer.capacity() != document_size) {
            Logger::printfln(HEAP_ALLOCATION_FAILED, document_size);
            return;
        }
#else
        if (size > MaxResponse) {
            Logger::printfln(TOO_MANY_JSON_FIELDS, size, "MaxResponse", MaxResponse);
            return;
        }
        auto constexpr document_size = JSON_OBJECT_SIZE(MaxResponse);
        StaticJsonDocument<document_size> json_buffer;
#endif // THINGSBOARD_ENABLE_DYNAMIC
#if THINGSBOARD_ENABLE_DEBUG
        Logger::printfln(ALLOCATING_JSON, document_size);
#endif // THINGSBOARD_ENABLE_DEBUG
 
        // The deserializeJson method we use, can use the zero copy mode because a writeable input was passed,
        // if that were not the case the needed allocated memory would drastically increase, because the keys would need to be copied as well.
        // See https://arduinojson.org/v6/doc/deserialization/ for more info on ArduinoJson deserialization
        DeserializationError const error = deserializeJson(json_buffer, payload, length);
        if (error) {
            Logger::printfln(UNABLE_TO_DE_SERIALIZE_JSON, error.c_str());
            return;
        }
 
#if THINGSBOARD_ENABLE_STL
#if THINGSBOARD_ENABLE_CXX20
        auto filtered_json_api_implementations = m_api_implementations | std::views::filter([&topic](IAPI_Implementation const * api) {
#else
        IAPI_Container filtered_json_api_implementations = {};
        std::copy_if(m_api_implementations.begin(), m_api_implementations.end(), std::back_inserter(filtered_json_api_implementations), [&topic](IAPI_Implementation const * api) {
#endif // THINGSBOARD_ENABLE_CXX20
            return (api != nullptr && api->Get_Process_Type() == API_Process_Type::JSON && api->Is_Response_Topic_Matching(topic));
        });
 
        for (auto & api : filtered_json_api_implementations) {
            api->Process_Json_Response(topic, json_buffer);
        }
#else
        for (auto & api : m_api_implementations) {
            if (api == nullptr || api->Get_Process_Type() != API_Process_Type::JSON || !api->Is_Response_Topic_Matching(topic)) {
                continue;
            }
            api->Process_Json_Response(topic, json_buffer);
        }
#endif // THINGSBOARD_ENABLE_STL
    }
 
#if !THINGSBOARD_ENABLE_STL
    static void On_Static_MQTT_Message(char * topic, uint8_t * payload, unsigned int length) {
        if (m_subscribedInstance == nullptr) {
            return;
        }
        m_subscribedInstance->On_MQTT_Message(topic, payload, length);
    }
 
    static void Static_MQTT_Connect() {
        if (m_subscribedInstance == nullptr) {
            return;
        }
        m_subscribedInstance->Resubscribe_Permanent_Subscriptionss();
    }
 
    static void Static_Subscribe_Implementation(IAPI_Implementation & api) {
        if (m_subscribedInstance == nullptr) {
            return;
        }
        m_subscribedInstance->Subscribe_API_Implementation(api);
    }
 
    static bool Static_Send_Json(char const * topic, JsonDocument const & source) {
        if (m_subscribedInstance == nullptr) {
            return false;
        }
        return m_subscribedInstance->Send_Json(topic, source);
    }
 
    static bool Static_Send_Json_String(char const * topic, char const * json) {
        if (m_subscribedInstance == nullptr) {
            return false;
        }
        return m_subscribedInstance->Send_Json_String(topic, json);
    }
 
    static bool Static_Subscribe_Topic(char const * topic) {
        if (m_subscribedInstance == nullptr) {
            return false;
        }
        return m_subscribedInstance->Subscribe_Topic(topic);
    }
 
    static bool Static_Unsubscribe_Topic(char const * topic) {
        if (m_subscribedInstance == nullptr) {
            return false;
        }
        return m_subscribedInstance->Unsubscribe_Topic(topic);
    }
 
    static size_t * Static_Get_Last_Request_ID() {
        if (m_subscribedInstance == nullptr) {
            return nullptr;
        }
        return m_subscribedInstance->Get_Last_Request_ID();
    }
 
    static uint16_t Static_Get_Receive_Buffer_Size() {
        if (m_subscribedInstance == nullptr) {
            return 0U;
        }
        return m_subscribedInstance->Get_Receive_Buffer_Size();
    }
 
    static uint16_t Static_Get_Send_Buffer_Size() {
        if (m_subscribedInstance == nullptr) {
            return 0U;
        }
        return m_subscribedInstance->Get_Send_Buffer_Size();
    }
 
    static bool Static_Set_Buffer_Size(uint16_t receive_buffer_size, uint16_t send_buffer_size) {
        if (m_subscribedInstance == nullptr) {
            return false;
        }
        return m_subscribedInstance->Set_Buffer_Size(receive_buffer_size, send_buffer_size);
    }
 
    static ThingsBoardSized *m_subscribedInstance;
#endif // !THINGSBOARD_ENABLE_STL
 
    IMQTT_Client&  m_client = {};              // MQTT client instance.
    size_t         m_max_stack = {};           // Maximum stack size we allocate at once.
    size_t         m_request_id = {};          // Internal id used to differentiate which request should receive which response for certain API calls. Can send 4'294'967'296 requests before wrapping back to 0
#if THINGSBOARD_ENABLE_STREAM_UTILS
    size_t         m_buffering_size = {};      // Buffering size used to serialize directly into client.
#endif // THINGSBOARD_ENABLE_STREAM_UTILS
#if THINGSBOARD_ENABLE_DYNAMIC
    size_t         m_max_response_size = {};   // Maximum size allocated on the heap to hold the Json data structure for received cloud response payload, prevents possible malicious payload allocaitng a lot of memory
#endif // THINGSBOARD_ENABLE_DYNAMIC    
    IAPI_Container m_api_implementations = {}; // Can hold a pointer to all  possible API implementations (Server side RPC, Client side RPC, Shared attribute update, Client-side or shared attribute request, Provision)             
};
 
#if !THINGSBOARD_ENABLE_STL
#if !THINGSBOARD_ENABLE_DYNAMIC
template<size_t MaxResponse, size_t MaxEndpointsAmount, typename Logger>
ThingsBoardSized<MaxResponse, MaxEndpointsAmount, Logger> *ThingsBoardSized<MaxResponse, MaxEndpointsAmount, Logger>::m_subscribedInstance = nullptr;
#else
template<typename Logger>
ThingsBoardSized<Logger> *ThingsBoardSized<Logger>::m_subscribedInstance = nullptr;
#endif // !THINGSBOARD_ENABLE_DYNAMIC
#endif // !THINGSBOARD_ENABLE_STL
 
using ThingsBoard = ThingsBoardSized<>;
 
#endif // ThingsBoard_h