esphome 2024.12.3__py3-none-any.whl

esphome/components/mqtt/custom_mqtt_device.h

@@ -0,0 +1,220 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#ifdef USE_MQTT
+
+#include "esphome/core/component.h"
+#include "mqtt_client.h"
+
+namespace esphome {
+namespace mqtt {
+
+/** This class is a helper class for custom components that communicate using
+ * MQTT. It has 5 helper functions that you can use (square brackets indicate optional):
+ *
+ *  - `subscribe(topic, function_pointer, [qos])`
+ *  - `subscribe_json(topic, function_pointer, [qos])`
+ *  - `publish(topic, payload, [qos], [retain])`
+ *  - `publish_json(topic, payload_builder, [qos], [retain])`
+ *  - `is_connected()`
+ */
+class CustomMQTTDevice {
+ public:
+  /** Subscribe to an MQTT topic with the given Quality of Service.
+   *
+   * Example:
+   *
+   * ```cpp
+   * class MyCustomMQTTDevice : public Component, public mqtt:CustomMQTTDevice {
+   *  public:
+   *   void setup() override {
+   *     subscribe("the/topic", &MyCustomMQTTDevice::on_message);
+   *     pinMode(5, OUTPUT);
+   *   }
+   *
+   *   // topic and payload parameters can be removed if not needed
+   *   // e.g: void on_message() {
+   *
+   *   void on_message(const std::string &topic, const std::string &payload) {
+   *     // do something with topic and payload
+   *     if (payload == "ON") {
+   *       digitalWrite(5, HIGH);
+   *     } else {
+   *       digitalWrite(5, LOW);
+   *     }
+   *   }
+   * };
+   * ```
+   *
+   * @tparam T A C++ template argument for determining the type of the callback.
+   * @param topic The topic to subscribe to. Re-subscription on re-connects is automatically handled.
+   * @param callback The callback (must be a class member) to subscribe with.
+   * @param qos The Quality of Service to subscribe with. Defaults to 0.
+   */
+  template<typename T>
+  void subscribe(const std::string &topic, void (T::*callback)(const std::string &, const std::string &),
+                 uint8_t qos = 0);
+
+  template<typename T>
+  void subscribe(const std::string &topic, void (T::*callback)(const std::string &), uint8_t qos = 0);
+
+  template<typename T> void subscribe(const std::string &topic, void (T::*callback)(), uint8_t qos = 0);
+
+  /** Subscribe to an MQTT topic and call the callback if the payload can be decoded
+   * as JSON with the given Quality of Service.
+   *
+   * Example:
+   *
+   * ```cpp
+   * class MyCustomMQTTDevice : public Component, public mqtt:CustomMQTTDevice {
+   *  public:
+   *   void setup() override {
+   *     subscribe_json("the/topic", &MyCustomMQTTDevice::on_json_message);
+   *     pinMode(5, OUTPUT);
+   *   }
+   *
+   *   // topic parameter can be remove if not needed:
+   *   // e.g.: void on_json_message(JsonObject payload) {
+   *
+   *   void on_json_message(const std::string &topic, JsonObject payload) {
+   *     // do something with topic and payload
+   *     if (payload["number"] == 1) {
+   *       digitalWrite(5, HIGH);
+   *     } else {
+   *       digitalWrite(5, LOW);
+   *     }
+   *   }
+   * };
+   * ```
+   *
+   * @tparam T A C++ template argument for determining the type of the callback.
+   * @param topic The topic to subscribe to. Re-subscription on re-connects is automatically handled.
+   * @param callback The callback (must be a class member) to subscribe with.
+   * @param qos The Quality of Service to subscribe with. Defaults to 0.
+   */
+  template<typename T>
+  void subscribe_json(const std::string &topic, void (T::*callback)(const std::string &, JsonObject), uint8_t qos = 0);
+
+  template<typename T> void subscribe_json(const std::string &topic, void (T::*callback)(JsonObject), uint8_t qos = 0);
+
+  /** Publish an MQTT message with the given payload and QoS and retain settings.
+   *
+   * Example:
+   *
+   * ```cpp
+   * void in_some_method() {
+   *   publish("the/topic", "The Payload", 0, true);
+   * }
+   * ```
+   *
+   * @param topic The topic to publish to.
+   * @param payload The payload to publish.
+   * @param qos The Quality of Service to publish with. Defaults to 0
+   * @param retain Whether to retain the message. Defaults to false.
+   */
+  bool publish(const std::string &topic, const std::string &payload, uint8_t qos = 0, bool retain = false);
+
+  /** Publish an MQTT message with the given floating point number and number of decimals.
+   *
+   * Example:
+   *
+   * ```cpp
+   * void in_some_method() {
+   *   publish("the/topic", 1.0);
+   *   // with two digits after the decimal point
+   *   publish("the/topic", 1.0, 2);
+   * }
+   * ```
+   *
+   * @param topic The topic to publish to.
+   * @param payload The payload to publish.
+   * @param number_decimals The number of digits after the decimal point to round to, defaults to 3 digits.
+   */
+  bool publish(const std::string &topic, float value, int8_t number_decimals = 3);
+
+  /** Publish an MQTT message with the given integer as payload.
+   *
+   * Example:
+   *
+   * ```cpp
+   * void in_some_method() {
+   *   publish("the/topic", 42);
+   * }
+   * ```
+   *
+   * @param topic The topic to publish to.
+   * @param payload The payload to publish.
+   */
+  bool publish(const std::string &topic, int value);
+
+  /** Publish a JSON-encoded MQTT message with the given Quality of Service and retain settings.
+   *
+   * Example:
+   *
+   * ```cpp
+   * void in_some_method() {
+   *   publish("the/topic", [=](JsonObject root) {
+   *     root["the_key"] = "Hello World!";
+   *   }, 0, false);
+   * }
+   * ```
+   *
+   * @param topic The topic to publish to.
+   * @param payload The payload to publish.
+   * @param qos The Quality of Service to publish with.
+   * @param retain Whether to retain the message.
+   */
+  bool publish_json(const std::string &topic, const json::json_build_t &f, uint8_t qos, bool retain);
+
+  /** Publish a JSON-encoded MQTT message.
+   *
+   * Example:
+   *
+   * ```cpp
+   * void in_some_method() {
+   *   publish("the/topic", [=](JsonObject root) {
+   *     root["the_key"] = "Hello World!";
+   *   });
+   * }
+   * ```
+   *
+   * @param topic The topic to publish to.
+   * @param payload The payload to publish.
+   */
+  bool publish_json(const std::string &topic, const json::json_build_t &f);
+
+  /// Check whether the MQTT client is currently connected and messages can be published.
+  bool is_connected();
+};
+
+template<typename T>
+void CustomMQTTDevice::subscribe(const std::string &topic,
+                                 void (T::*callback)(const std::string &, const std::string &), uint8_t qos) {
+  auto f = std::bind(callback, (T *) this, std::placeholders::_1, std::placeholders::_2);
+  global_mqtt_client->subscribe(topic, f, qos);
+}
+template<typename T>
+void CustomMQTTDevice::subscribe(const std::string &topic, void (T::*callback)(const std::string &), uint8_t qos) {
+  auto f = std::bind(callback, (T *) this, std::placeholders::_2);
+  global_mqtt_client->subscribe(topic, f, qos);
+}
+template<typename T> void CustomMQTTDevice::subscribe(const std::string &topic, void (T::*callback)(), uint8_t qos) {
+  auto f = std::bind(callback, (T *) this);
+  global_mqtt_client->subscribe(topic, f, qos);
+}
+template<typename T>
+void CustomMQTTDevice::subscribe_json(const std::string &topic, void (T::*callback)(const std::string &, JsonObject),
+                                      uint8_t qos) {
+  auto f = std::bind(callback, (T *) this, std::placeholders::_1, std::placeholders::_2);
+  global_mqtt_client->subscribe_json(topic, f, qos);
+}
+template<typename T>
+void CustomMQTTDevice::subscribe_json(const std::string &topic, void (T::*callback)(JsonObject), uint8_t qos) {
+  auto f = std::bind(callback, (T *) this, std::placeholders::_2);
+  global_mqtt_client->subscribe_json(topic, f, qos);
+}
+
+}  // namespace mqtt
+}  // namespace esphome
+
+#endif  // USE_MQTT

esphome/components/mqtt/mqtt_alarm_control_panel.cpp

@@ -0,0 +1,125 @@
+#include "mqtt_alarm_control_panel.h"
+#include "esphome/core/log.h"
+
+#include "mqtt_const.h"
+
+#ifdef USE_MQTT
+#ifdef USE_ALARM_CONTROL_PANEL
+
+namespace esphome {
+namespace mqtt {
+
+static const char *const TAG = "mqtt.alarm_control_panel";
+
+using namespace esphome::alarm_control_panel;
+
+MQTTAlarmControlPanelComponent::MQTTAlarmControlPanelComponent(AlarmControlPanel *alarm_control_panel)
+    : alarm_control_panel_(alarm_control_panel) {}
+void MQTTAlarmControlPanelComponent::setup() {
+  this->alarm_control_panel_->add_on_state_callback([this]() { this->publish_state(); });
+  this->subscribe(this->get_command_topic_(), [this](const std::string &topic, const std::string &payload) {
+    auto call = this->alarm_control_panel_->make_call();
+    if (strcasecmp(payload.c_str(), "ARM_AWAY") == 0) {
+      call.arm_away();
+    } else if (strcasecmp(payload.c_str(), "ARM_HOME") == 0) {
+      call.arm_home();
+    } else if (strcasecmp(payload.c_str(), "ARM_NIGHT") == 0) {
+      call.arm_night();
+    } else if (strcasecmp(payload.c_str(), "ARM_VACATION") == 0) {
+      call.arm_vacation();
+    } else if (strcasecmp(payload.c_str(), "ARM_CUSTOM_BYPASS") == 0) {
+      call.arm_custom_bypass();
+    } else if (strcasecmp(payload.c_str(), "DISARM") == 0) {
+      call.disarm();
+    } else if (strcasecmp(payload.c_str(), "PENDING") == 0) {
+      call.pending();
+    } else if (strcasecmp(payload.c_str(), "TRIGGERED") == 0) {
+      call.triggered();
+    } else {
+      ESP_LOGW(TAG, "'%s': Received unknown command payload %s", this->friendly_name().c_str(), payload.c_str());
+    }
+    call.perform();
+  });
+}
+
+void MQTTAlarmControlPanelComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "MQTT alarm_control_panel '%s':", this->alarm_control_panel_->get_name().c_str());
+  LOG_MQTT_COMPONENT(true, true)
+  ESP_LOGCONFIG(TAG, "  Supported Features: %" PRIu32, this->alarm_control_panel_->get_supported_features());
+  ESP_LOGCONFIG(TAG, "  Requires Code to Disarm: %s", YESNO(this->alarm_control_panel_->get_requires_code()));
+  ESP_LOGCONFIG(TAG, "  Requires Code To Arm: %s", YESNO(this->alarm_control_panel_->get_requires_code_to_arm()));
+}
+
+void MQTTAlarmControlPanelComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) {
+  JsonArray supported_features = root.createNestedArray(MQTT_SUPPORTED_FEATURES);
+  const uint32_t acp_supported_features = this->alarm_control_panel_->get_supported_features();
+  if (acp_supported_features & ACP_FEAT_ARM_AWAY) {
+    supported_features.add("arm_away");
+  }
+  if (acp_supported_features & ACP_FEAT_ARM_HOME) {
+    supported_features.add("arm_home");
+  }
+  if (acp_supported_features & ACP_FEAT_ARM_NIGHT) {
+    supported_features.add("arm_night");
+  }
+  if (acp_supported_features & ACP_FEAT_ARM_VACATION) {
+    supported_features.add("arm_vacation");
+  }
+  if (acp_supported_features & ACP_FEAT_ARM_CUSTOM_BYPASS) {
+    supported_features.add("arm_custom_bypass");
+  }
+  if (acp_supported_features & ACP_FEAT_TRIGGER) {
+    supported_features.add("trigger");
+  }
+  root[MQTT_CODE_DISARM_REQUIRED] = this->alarm_control_panel_->get_requires_code();
+  root[MQTT_CODE_ARM_REQUIRED] = this->alarm_control_panel_->get_requires_code_to_arm();
+}
+
+std::string MQTTAlarmControlPanelComponent::component_type() const { return "alarm_control_panel"; }
+const EntityBase *MQTTAlarmControlPanelComponent::get_entity() const { return this->alarm_control_panel_; }
+
+bool MQTTAlarmControlPanelComponent::send_initial_state() { return this->publish_state(); }
+bool MQTTAlarmControlPanelComponent::publish_state() {
+  const char *state_s;
+  switch (this->alarm_control_panel_->get_state()) {
+    case ACP_STATE_DISARMED:
+      state_s = "disarmed";
+      break;
+    case ACP_STATE_ARMED_HOME:
+      state_s = "armed_home";
+      break;
+    case ACP_STATE_ARMED_AWAY:
+      state_s = "armed_away";
+      break;
+    case ACP_STATE_ARMED_NIGHT:
+      state_s = "armed_night";
+      break;
+    case ACP_STATE_ARMED_VACATION:
+      state_s = "armed_vacation";
+      break;
+    case ACP_STATE_ARMED_CUSTOM_BYPASS:
+      state_s = "armed_custom_bypass";
+      break;
+    case ACP_STATE_PENDING:
+      state_s = "pending";
+      break;
+    case ACP_STATE_ARMING:
+      state_s = "arming";
+      break;
+    case ACP_STATE_DISARMING:
+      state_s = "disarming";
+      break;
+    case ACP_STATE_TRIGGERED:
+      state_s = "triggered";
+      break;
+    default:
+      state_s = "unknown";
+  }
+  return this->publish(this->get_state_topic_(), state_s);
+}
+
+}  // namespace mqtt
+}  // namespace esphome
+
+#endif
+#endif  // USE_MQTT

esphome/components/mqtt/mqtt_alarm_control_panel.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_MQTT
+#ifdef USE_ALARM_CONTROL_PANEL
+
+#include "mqtt_component.h"
+#include "esphome/components/alarm_control_panel/alarm_control_panel.h"
+
+namespace esphome {
+namespace mqtt {
+
+class MQTTAlarmControlPanelComponent : public mqtt::MQTTComponent {
+ public:
+  explicit MQTTAlarmControlPanelComponent(alarm_control_panel::AlarmControlPanel *alarm_control_panel);
+
+  void setup() override;
+
+  void send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) override;
+
+  bool send_initial_state() override;
+
+  bool publish_state();
+
+  void dump_config() override;
+
+ protected:
+  std::string component_type() const override;
+  const EntityBase *get_entity() const override;
+
+  alarm_control_panel::AlarmControlPanel *alarm_control_panel_;
+};
+
+}  // namespace mqtt
+}  // namespace esphome
+
+#endif
+#endif  // USE_MQTT

esphome/components/mqtt/mqtt_backend.h

@@ -0,0 +1,71 @@
+#pragma once
+#include "esphome/core/defines.h"
+#ifdef USE_MQTT
+#include <string>
+#include <map>
+#include "esphome/components/network/ip_address.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace mqtt {
+
+enum class MQTTClientDisconnectReason : int8_t {
+  TCP_DISCONNECTED = 0,
+  MQTT_UNACCEPTABLE_PROTOCOL_VERSION = 1,
+  MQTT_IDENTIFIER_REJECTED = 2,
+  MQTT_SERVER_UNAVAILABLE = 3,
+  MQTT_MALFORMED_CREDENTIALS = 4,
+  MQTT_NOT_AUTHORIZED = 5,
+  ESP8266_NOT_ENOUGH_SPACE = 6,
+  TLS_BAD_FINGERPRINT = 7
+};
+
+/// internal struct for MQTT messages.
+struct MQTTMessage {
+  std::string topic;
+  std::string payload;
+  uint8_t qos;  ///< QoS. Only for last will testaments.
+  bool retain;
+};
+
+class MQTTBackend {
+ public:
+  using on_connect_callback_t = void(bool session_present);
+  using on_disconnect_callback_t = void(MQTTClientDisconnectReason reason);
+  using on_subscribe_callback_t = void(uint16_t packet_id, uint8_t qos);
+  using on_unsubscribe_callback_t = void(uint16_t packet_id);
+  using on_message_callback_t = void(const char *topic, const char *payload, size_t len, size_t index, size_t total);
+  using on_publish_user_callback_t = void(uint16_t packet_id);
+
+  virtual void set_keep_alive(uint16_t keep_alive) = 0;
+  virtual void set_client_id(const char *client_id) = 0;
+  virtual void set_clean_session(bool clean_session) = 0;
+  virtual void set_credentials(const char *username, const char *password) = 0;
+  virtual void set_will(const char *topic, uint8_t qos, bool retain, const char *payload) = 0;
+  virtual void set_server(network::IPAddress ip, uint16_t port) = 0;
+  virtual void set_server(const char *host, uint16_t port) = 0;
+  virtual void set_on_connect(std::function<on_connect_callback_t> &&callback) = 0;
+  virtual void set_on_disconnect(std::function<on_disconnect_callback_t> &&callback) = 0;
+  virtual void set_on_subscribe(std::function<on_subscribe_callback_t> &&callback) = 0;
+  virtual void set_on_unsubscribe(std::function<on_unsubscribe_callback_t> &&callback) = 0;
+  virtual void set_on_message(std::function<on_message_callback_t> &&callback) = 0;
+  virtual void set_on_publish(std::function<on_publish_user_callback_t> &&callback) = 0;
+  virtual bool connected() const = 0;
+  virtual void connect() = 0;
+  virtual void disconnect() = 0;
+  virtual bool subscribe(const char *topic, uint8_t qos) = 0;
+  virtual bool unsubscribe(const char *topic) = 0;
+  virtual bool publish(const char *topic, const char *payload, size_t length, uint8_t qos, bool retain) = 0;
+
+  virtual bool publish(const MQTTMessage &message) {
+    return publish(message.topic.c_str(), message.payload.c_str(), message.payload.length(), message.qos,
+                   message.retain);
+  }
+
+  // called from MQTTClient::loop()
+  virtual void loop() {}
+};
+
+}  // namespace mqtt
+}  // namespace esphome
+#endif

esphome/components/mqtt/mqtt_backend_esp32.cpp

@@ -0,0 +1,194 @@
+#include "mqtt_backend_esp32.h"
+
+#ifdef USE_MQTT
+#ifdef USE_ESP32
+
+#include <string>
+#include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace mqtt {
+
+static const char *const TAG = "mqtt.idf";
+
+bool MQTTBackendESP32::initialize_() {
+#if ESP_IDF_VERSION_MAJOR < 5
+  mqtt_cfg_.user_context = (void *) this;
+  mqtt_cfg_.buffer_size = MQTT_BUFFER_SIZE;
+
+  mqtt_cfg_.host = this->host_.c_str();
+  mqtt_cfg_.port = this->port_;
+  mqtt_cfg_.keepalive = this->keep_alive_;
+  mqtt_cfg_.disable_clean_session = !this->clean_session_;
+
+  if (!this->username_.empty()) {
+    mqtt_cfg_.username = this->username_.c_str();
+    if (!this->password_.empty()) {
+      mqtt_cfg_.password = this->password_.c_str();
+    }
+  }
+
+  if (!this->lwt_topic_.empty()) {
+    mqtt_cfg_.lwt_topic = this->lwt_topic_.c_str();
+    this->mqtt_cfg_.lwt_qos = this->lwt_qos_;
+    this->mqtt_cfg_.lwt_retain = this->lwt_retain_;
+
+    if (!this->lwt_message_.empty()) {
+      mqtt_cfg_.lwt_msg = this->lwt_message_.c_str();
+      mqtt_cfg_.lwt_msg_len = this->lwt_message_.size();
+    }
+  }
+
+  if (!this->client_id_.empty()) {
+    mqtt_cfg_.client_id = this->client_id_.c_str();
+  }
+  if (ca_certificate_.has_value()) {
+    mqtt_cfg_.cert_pem = ca_certificate_.value().c_str();
+    mqtt_cfg_.skip_cert_common_name_check = skip_cert_cn_check_;
+    mqtt_cfg_.transport = MQTT_TRANSPORT_OVER_SSL;
+
+    if (this->cl_certificate_.has_value() && this->cl_key_.has_value()) {
+      mqtt_cfg_.client_cert_pem = this->cl_certificate_.value().c_str();
+      mqtt_cfg_.client_key_pem = this->cl_key_.value().c_str();
+    }
+  } else {
+    mqtt_cfg_.transport = MQTT_TRANSPORT_OVER_TCP;
+  }
+#else
+  mqtt_cfg_.broker.address.hostname = this->host_.c_str();
+  mqtt_cfg_.broker.address.port = this->port_;
+  mqtt_cfg_.session.keepalive = this->keep_alive_;
+  mqtt_cfg_.session.disable_clean_session = !this->clean_session_;
+
+  if (!this->username_.empty()) {
+    mqtt_cfg_.credentials.username = this->username_.c_str();
+    if (!this->password_.empty()) {
+      mqtt_cfg_.credentials.authentication.password = this->password_.c_str();
+    }
+  }
+
+  if (!this->lwt_topic_.empty()) {
+    mqtt_cfg_.session.last_will.topic = this->lwt_topic_.c_str();
+    this->mqtt_cfg_.session.last_will.qos = this->lwt_qos_;
+    this->mqtt_cfg_.session.last_will.retain = this->lwt_retain_;
+
+    if (!this->lwt_message_.empty()) {
+      mqtt_cfg_.session.last_will.msg = this->lwt_message_.c_str();
+      mqtt_cfg_.session.last_will.msg_len = this->lwt_message_.size();
+    }
+  }
+
+  if (!this->client_id_.empty()) {
+    mqtt_cfg_.credentials.client_id = this->client_id_.c_str();
+  }
+  if (ca_certificate_.has_value()) {
+    mqtt_cfg_.broker.verification.certificate = ca_certificate_.value().c_str();
+    mqtt_cfg_.broker.verification.skip_cert_common_name_check = skip_cert_cn_check_;
+    mqtt_cfg_.broker.address.transport = MQTT_TRANSPORT_OVER_SSL;
+
+    if (this->cl_certificate_.has_value() && this->cl_key_.has_value()) {
+      mqtt_cfg_.credentials.authentication.certificate = this->cl_certificate_.value().c_str();
+      mqtt_cfg_.credentials.authentication.key = this->cl_key_.value().c_str();
+    }
+  } else {
+    mqtt_cfg_.broker.address.transport = MQTT_TRANSPORT_OVER_TCP;
+  }
+#endif
+  auto *mqtt_client = esp_mqtt_client_init(&mqtt_cfg_);
+  if (mqtt_client) {
+    handler_.reset(mqtt_client);
+    is_initalized_ = true;
+    esp_mqtt_client_register_event(mqtt_client, MQTT_EVENT_ANY, mqtt_event_handler, this);
+    return true;
+  } else {
+    ESP_LOGE(TAG, "Failed to initialize IDF-MQTT");
+    return false;
+  }
+}
+
+void MQTTBackendESP32::loop() {
+  // process new events
+  // handle only 1 message per loop iteration
+  if (!mqtt_events_.empty()) {
+    auto &event = mqtt_events_.front();
+    mqtt_event_handler_(event);
+    mqtt_events_.pop();
+  }
+}
+
+void MQTTBackendESP32::mqtt_event_handler_(const Event &event) {
+  ESP_LOGV(TAG, "Event dispatched from event loop event_id=%d", event.event_id);
+  switch (event.event_id) {
+    case MQTT_EVENT_BEFORE_CONNECT:
+      ESP_LOGV(TAG, "MQTT_EVENT_BEFORE_CONNECT");
+      break;
+
+    case MQTT_EVENT_CONNECTED:
+      ESP_LOGV(TAG, "MQTT_EVENT_CONNECTED");
+      this->is_connected_ = true;
+      this->on_connect_.call(event.session_present);
+      break;
+    case MQTT_EVENT_DISCONNECTED:
+      ESP_LOGV(TAG, "MQTT_EVENT_DISCONNECTED");
+      // TODO is there a way to get the disconnect reason?
+      this->is_connected_ = false;
+      this->on_disconnect_.call(MQTTClientDisconnectReason::TCP_DISCONNECTED);
+      break;
+
+    case MQTT_EVENT_SUBSCRIBED:
+      ESP_LOGV(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event.msg_id);
+      // hardcode QoS to 0. QoS is not used in this context but required to mirror the AsyncMqtt interface
+      this->on_subscribe_.call((int) event.msg_id, 0);
+      break;
+    case MQTT_EVENT_UNSUBSCRIBED:
+      ESP_LOGV(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event.msg_id);
+      this->on_unsubscribe_.call((int) event.msg_id);
+      break;
+    case MQTT_EVENT_PUBLISHED:
+      ESP_LOGV(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event.msg_id);
+      this->on_publish_.call((int) event.msg_id);
+      break;
+    case MQTT_EVENT_DATA: {
+      static std::string topic;
+      if (!event.topic.empty()) {
+        topic = event.topic;
+      }
+      ESP_LOGV(TAG, "MQTT_EVENT_DATA %s", topic.c_str());
+      this->on_message_.call(!event.topic.empty() ? topic.c_str() : nullptr, event.data.data(), event.data.size(),
+                             event.current_data_offset, event.total_data_len);
+    } break;
+    case MQTT_EVENT_ERROR:
+      ESP_LOGE(TAG, "MQTT_EVENT_ERROR");
+      if (event.error_handle.error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
+        ESP_LOGE(TAG, "Last error code reported from esp-tls: 0x%x", event.error_handle.esp_tls_last_esp_err);
+        ESP_LOGE(TAG, "Last tls stack error number: 0x%x", event.error_handle.esp_tls_stack_err);
+        ESP_LOGE(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_LOGE(TAG, "Connection refused error: 0x%x", event.error_handle.connect_return_code);
+      } else {
+        ESP_LOGE(TAG, "Unknown error type: 0x%x", event.error_handle.error_type);
+      }
+      break;
+    default:
+      ESP_LOGV(TAG, "Other event id:%d", event.event_id);
+      break;
+  }
+}
+
+/// static - Dispatch event to instance method
+void MQTTBackendESP32::mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id,
+                                          void *event_data) {
+  MQTTBackendESP32 *instance = static_cast<MQTTBackendESP32 *>(handler_args);
+  // queue event to decouple processing
+  if (instance) {
+    auto event = *static_cast<esp_mqtt_event_t *>(event_data);
+    instance->mqtt_events_.emplace(event);
+  }
+}
+
+}  // namespace mqtt
+}  // namespace esphome
+#endif  // USE_ESP32
+#endif