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/component.h"
#include "esphome/core/entity_base.h"
#include "mqtt_client.h"

namespace esphome {
namespace mqtt {

struct SendDiscoveryConfig {
  bool state_topic{true};    
  bool command_topic{true};  
};

#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()); \
  }

#define MQTT_COMPONENT_CUSTOM_TOPIC_(name, type) \
 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_retain(bool retain);
  bool get_retain() const;

  void disable_discovery();
  bool is_discovery_enabled() const;

  virtual std::string component_type() const = 0;

  void set_custom_state_topic(const std::string &custom_state_topic);
  void set_custom_command_topic(const std::string &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_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;

  virtual std::string unique_id();

  virtual std::string friendly_name() const;

  virtual std::string get_icon() const;

  virtual 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)
  std::string get_default_object_id_() const;

  std::string custom_state_topic_{};
  std::string custom_command_topic_{};
  bool has_custom_state_topic_{false};
  bool has_custom_command_topic_{false};

  bool command_retain_{false};
  bool retain_{true};
  bool discovery_enabled_{true};
  std::unique_ptr<Availability> availability_;
  bool resend_state_{false};
};

}  // namespace mqtt
}  // namespace esphome

#endif  // USE_MQTt