DualLedController/components/Communication/MqttClient.cpp

#include "MqttClient.h"
#include "LedController.h"
#include <cJSON.h>
#include <esp_log.h>
#include <iostream>
#include <string_view>

static const char *TAG = "mqtt";

void MqttClient::onConnected(struct esp_mqtt_client *client) {
    ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");

    cJSON *root = cJSON_CreateObject();
    cJSON_AddStringToObject(root, "~", "homeassistant/light/bedroom");
    cJSON_AddStringToObject(root, "name", "Bedroom");
    cJSON_AddStringToObject(root, "uniq_id", "bedroom_light");
    cJSON_AddStringToObject(root, "cmd_t", "~/set");
    cJSON_AddStringToObject(root, "stat_t", "~/state");
    cJSON_AddStringToObject(root, "schema", "json");
    cJSON_AddNumberToObject(root, "brightness_scale", 100);

    const char *modes[] = {
        "color_temp",
    };
    cJSON *supported_color_modes = cJSON_CreateStringArray(modes, sizeof(modes) / sizeof(modes[0]));
    cJSON_AddItemToObject(root, "supported_color_modes", supported_color_modes);

    cJSON_AddTrueToObject(root, "brightness");
    auto json = cJSON_PrintUnformatted(root);
    int msg_id = esp_mqtt_client_publish(client, "homeassistant/light/bedroom/config", json, strlen(json), 1, 0);
    cJSON_free(json);
    cJSON_Delete(root);
    ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);

    m_setStatusTopic = "homeassistant/light/bedroom/set";
    msg_id = esp_mqtt_client_subscribe(client, m_setStatusTopic.c_str(), 0);
    ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
}

void MqttClient::onSetStatus(const char *data, int size) {
    ESP_LOGI(TAG, "set: %s", data);
    cJSON *root = cJSON_Parse(data);
    cJSON *brightness = cJSON_GetObjectItem(root, "brightness");
    if (brightness != nullptr) {
        ESP_LOGI(TAG, "brightness: %d", brightness->valueint);
        LedController::instance()->setDuty(1, brightness->valueint);
    }

    cJSON_Delete(root);
}

static void log_error_if_nonzero(const char *message, int error_code) {
    if (error_code != 0) {
        ESP_LOGE(TAG, "Last error %s: 0x%x", message, error_code);
    }
}

void MqttClient::eventHandler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) {
    auto self = reinterpret_cast<MqttClient *>(handler_args);
    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32 "", base, event_id);
    auto event = reinterpret_cast<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:
        self->onConnected(client);
        break;
    case MQTT_EVENT_DISCONNECTED:
        ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
        break;

    case MQTT_EVENT_SUBSCRIBED:
        ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
        msg_id = esp_mqtt_client_publish(client, "/topic/qos0", "data", 0, 0, 0);
        ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
        break;
    case MQTT_EVENT_UNSUBSCRIBED:
        ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_PUBLISHED:
        ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
        break;
    case MQTT_EVENT_DATA:
        ESP_LOGI(TAG, "MQTT_EVENT_DATA %s", self->m_setStatusTopic.c_str());
        if (self->m_setStatusTopic == std::string_view(event->topic, event->topic_len)) {
            self->onSetStatus(event->data, event->data_len);
        } else {
            printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
            printf("DATA=%.*s\r\n", event->data_len, event->data);
        }
        break;
    case MQTT_EVENT_ERROR:
        ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
        if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
            log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err);
            log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err);
            log_error_if_nonzero("captured as transport's socket errno", event->error_handle->esp_transport_sock_errno);
            ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno));
        }
        break;
    default:
        ESP_LOGI(TAG, "Other event id:%d", event->event_id);
        break;
    }
}

bool MqttClient::initialize(const std::string &username, const std::string &password) {
    esp_mqtt_client_config_t config;
    memset(&config, 0, sizeof(esp_mqtt_client_config_t));
    config.broker.address.uri = "mqtt://192.168.2.3";
    config.credentials.username = username.c_str();
    config.credentials.authentication.password = password.c_str();

    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&config);
    esp_mqtt_client_register_event(client, static_cast<esp_mqtt_event_id_t>(ESP_EVENT_ANY_ID),
                                   &MqttClient::eventHandler, this);
    esp_mqtt_client_start(client);
    ESP_LOGI(TAG, "connect to %s, username: %s, password: %s", config.broker.address.uri, config.credentials.username,
             config.credentials.authentication.password);
    return true;
}

MqttClient *MqttClient::instance() {
    static MqttClient self;
    return &self;
}