mqtt_component.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/defines.h"
 
#ifdef USE_MQTT
 
#include <memory>
 
#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/entity_base.h"
#include "esphome/core/string_ref.h"
#include "mqtt_client.h"
 
namespace esphome::mqtt {
 
struct SendDiscoveryConfig {
  bool state_topic{true};    
  bool command_topic{true};  
};
 
// Max lengths for stack-based topic building (must match mqtt_component.cpp)
static constexpr size_t MQTT_COMPONENT_TYPE_MAX_LEN = 20;
static constexpr size_t MQTT_SUFFIX_MAX_LEN = 32;
 
#define LOG_MQTT_COMPONENT(state_topic, command_topic) \
  if (state_topic) { \
    ESP_LOGCONFIG(TAG, "  State Topic: '%s'", this->get_state_topic_().c_str()); \
  } \
  if (command_topic) { \
    ESP_LOGCONFIG(TAG, "  Command Topic: '%s'", this->get_command_topic_().c_str()); \
  }
 
// Macro to define component_type() with compile-time length verification
// Usage: MQTT_COMPONENT_TYPE(MQTTSensorComponent, "sensor")
#define MQTT_COMPONENT_TYPE(class_name, type_str) \
  const char *class_name::component_type() const { return type_str; } \
  static_assert(sizeof(type_str) - 1 <= MQTT_COMPONENT_TYPE_MAX_LEN, \
                #class_name "::component_type() exceeds MQTT_COMPONENT_TYPE_MAX_LEN");
 
// Macro to define custom topic getter/setter with compile-time suffix length verification
#define MQTT_COMPONENT_CUSTOM_TOPIC_(name, type) \
  static_assert(sizeof(#name "/" #type) - 1 <= MQTT_SUFFIX_MAX_LEN, \
                "topic suffix " #name "/" #type " exceeds MQTT_SUFFIX_MAX_LEN"); \
\
 protected: \
  std::string custom_##name##_##type##_topic_{}; \
\
 public: \
  void set_custom_##name##_##type##_topic(const std::string &topic) { this->custom_##name##_##type##_topic_ = topic; } \
  std::string get_##name##_##type##_topic() const { \
    if (this->custom_##name##_##type##_topic_.empty()) \
      return this->get_default_topic_for_(#name "/" #type); \
    return this->custom_##name##_##type##_topic_; \
  }
 
#define MQTT_COMPONENT_CUSTOM_TOPIC(name, type) MQTT_COMPONENT_CUSTOM_TOPIC_(name, type)
 
class MQTTComponent : public Component {
 public:
  explicit MQTTComponent();
 
  void call_setup() override;
 
  void call_loop() override;
 
  void call_dump_config() override;
 
  virtual void send_discovery(JsonObject root, SendDiscoveryConfig &config) = 0;
 
  virtual bool send_initial_state() = 0;
 
  virtual bool is_internal();
 
  void set_qos(uint8_t qos);
  uint8_t get_qos() const;
 
  void set_retain(bool retain);
  bool get_retain() const;
 
  void disable_discovery();
  bool is_discovery_enabled() const;
 
  void set_subscribe_qos(uint8_t qos);
 
  virtual const char *component_type() const = 0;
 
  template<typename T> void set_custom_state_topic(T &&custom_state_topic) {
    this->custom_state_topic_ = std::forward<T>(custom_state_topic);
  }
  template<typename T> void set_custom_command_topic(T &&custom_command_topic) {
    this->custom_command_topic_ = std::forward<T>(custom_command_topic);
  }
  void set_command_retain(bool command_retain);
 
  float get_setup_priority() const override;
 
  void set_availability(std::string topic, std::string payload_available, std::string payload_not_available);
  void disable_availability();
 
  void schedule_resend_state();
 
  bool publish(const std::string &topic, const std::string &payload);
 
  bool publish(const std::string &topic, const char *payload, size_t payload_length);
 
  bool publish_json(const std::string &topic, const json::json_build_t &f);
 
  void subscribe(const std::string &topic, mqtt_callback_t callback, uint8_t qos = 0);
 
  void subscribe_json(const std::string &topic, const mqtt_json_callback_t &callback, uint8_t qos = 0);
 
 protected:
  std::string get_discovery_topic_(const MQTTDiscoveryInfo &discovery_info) const;
 
  std::string get_default_topic_for_(const std::string &suffix) const;
 
  virtual const EntityBase *get_entity() const = 0;
 
  std::string friendly_name_() const;
 
  StringRef get_icon_ref_() const;
 
  bool is_disabled_by_default_() const;
 
  std::string get_state_topic_() const;
 
  std::string get_command_topic_() const;
 
  bool is_connected_() const;
 
  bool send_discovery_();
 
  // ========== INTERNAL METHODS ==========
  // (In most use cases you won't need these)
  StringRef get_default_object_id_to_(std::span<char, OBJECT_ID_MAX_LEN> buf) const;
 
  TemplatableValue<std::string> custom_state_topic_{};
  TemplatableValue<std::string> custom_command_topic_{};
 
  std::unique_ptr<Availability> availability_;
 
  bool command_retain_{false};
  bool retain_{true};
  uint8_t qos_{0};
  uint8_t subscribe_qos_{0};
  bool discovery_enabled_{true};
  bool resend_state_{false};
};
 
}  // namespace esphome::mqtt
 
#endif  // USE_MQTt