blinky-esp/main/mqtt.cpp

static const char *TAG = "mqtt";
#include <esp_log.h>

#include "mqtt.hpp"


extern const uint8_t broker_pem_start[] asm("_binary_broker_pem_start");


typedef struct {
    mqtt_connect_handler connect;
    mqtt_message_handler message;
    void* data;
} mqtt_client_data;


static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) {
    mqtt_client_data *client_data = (mqtt_client_data*)handler_args;
    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%d", base, event_id);
    esp_mqtt_event_handle_t event = (esp_mqtt_event_handle_t)event_data;
    esp_mqtt_client_handle_t client = event->client;
    int msg_id;
    switch ((esp_mqtt_event_id_t)event_id) {
    case MQTT_EVENT_CONNECTED:
        ESP_LOGD(TAG, "MQTT_EVENT_CONNECTED");
        if (client_data && client_data->connect) {
            client_data->connect(client, client_data->data);
        }
        break;
    case MQTT_EVENT_DISCONNECTED:
        ESP_LOGD(TAG, "MQTT_EVENT_DISCONNECTED");
        break;
    case MQTT_EVENT_SUBSCRIBED:
        ESP_LOGD(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_UNSUBSCRIBED:
        ESP_LOGD(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_PUBLISHED:
        ESP_LOGD(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_DATA:
        ESP_LOGD(TAG, "MQTT_EVENT_DATA");
        ESP_LOGD(TAG, "TOPIC=%.*s\r\n", event->topic_len, event->topic);
        ESP_LOGD(TAG, "DATA=%.*s\r\n", event->data_len, event->data);
        if (client_data && client_data->message) {
            client_data->message(client, event, client_data->data);
        }
        break;
    case MQTT_EVENT_ERROR:
        ESP_LOGD(TAG, "MQTT_EVENT_ERROR");
        if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
            ESP_LOGW(TAG, "Last error code reported from esp-tls: 0x%x", event->error_handle->esp_tls_last_esp_err);
            ESP_LOGW(TAG, "Last tls stack error number: 0x%x", event->error_handle->esp_tls_stack_err);
            ESP_LOGW(TAG, "Last captured errno : %d (%s)",  event->error_handle->esp_transport_sock_errno,
                     strerror(event->error_handle->esp_transport_sock_errno));
        } else if (event->error_handle->error_type == MQTT_ERROR_TYPE_CONNECTION_REFUSED) {
            ESP_LOGW(TAG, "Connection refused error: 0x%x", event->error_handle->connect_return_code);
        } else {
            ESP_LOGW(TAG, "Unknown error type: 0x%x", event->error_handle->error_type);
        }
        break;
/*
    case MQTT_USER_EVENT:
        event->data = (char*)handler_args;
        break;
*/
    default:
        ESP_LOGD(TAG, "Other event id:%d", event->event_id);
        break;
    }
}

esp_mqtt_client_handle_t start_mqtt_client(
            mqtt_connect_handler connect,
            mqtt_message_handler message,
            void* data
        ) {
    ESP_LOGI(TAG, "Starting MQTT client");

    mqtt_client_data* client_data = (mqtt_client_data*)malloc(sizeof(*client_data));
    client_data->connect = connect;
    client_data->message = message;
    client_data->data = data;

    const esp_mqtt_client_config_t mqtt_cfg = {
        .uri = CONFIG_BROKER_URI,
        .cert_pem = (const char *)broker_pem_start,
        .username = CONFIG_BROKER_USER,
        .password = CONFIG_BROKER_PASSWORD,
        .buffer_size = 4096,
    };

    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt_cfg);
    esp_mqtt_client_register_event(client, MQTT_EVENT_ANY, mqtt_event_handler, client_data);
    esp_mqtt_client_start(client);

    return client;
}

void stop_mqtt_client(esp_mqtt_client_handle_t client) {
/*
    // Hijack the user event to grab the client data on the heap
    esp_mqtt_event_t event;
    esp_mqtt_dispatch_custom_event(client, &event);
    esp_mqtt_client_stop(client);
    free((mqtt_client_data*)event->data)
*/
}