ESPHome 2025.6.0
Loading...
Searching...
No Matches
mqtt_client.cpp
Go to the documentation of this file.
1#include "mqtt_client.h"
2
3#ifdef USE_MQTT
4
5#include <utility>
9#include "esphome/core/log.h"
11#ifdef USE_LOGGER
13#endif
14#include "lwip/dns.h"
15#include "lwip/err.h"
16#include "mqtt_component.h"
17
18#ifdef USE_API
20#endif
21#ifdef USE_DASHBOARD_IMPORT
23#endif
24
25namespace esphome {
26namespace mqtt {
27
28static const char *const TAG = "mqtt";
29
31 global_mqtt_client = this;
33}
34
35// Connection
37 ESP_LOGCONFIG(TAG, "Running setup");
39 [this](const char *topic, const char *payload, size_t len, size_t index, size_t total) {
40 if (index == 0)
41 this->payload_buffer_.reserve(total);
42
43 // append new payload, may contain incomplete MQTT message
44 this->payload_buffer_.append(payload, len);
45
46 // MQTT fully received
47 if (len + index == total) {
48 this->on_message(topic, this->payload_buffer_);
49 this->payload_buffer_.clear();
50 }
51 });
53 if (this->state_ == MQTT_CLIENT_DISABLED)
54 return;
56 this->disconnect_reason_ = reason;
57 });
58#ifdef USE_LOGGER
59 if (this->is_log_message_enabled() && logger::global_logger != nullptr) {
60 logger::global_logger->add_on_log_callback([this](int level, const char *tag, const char *message) {
61 if (level <= this->log_level_ && this->is_connected()) {
62 this->publish({.topic = this->log_message_.topic,
63 .payload = message,
64 .qos = this->log_message_.qos,
65 .retain = this->log_message_.retain});
66 }
67 });
68 }
69#endif
70
71 if (this->is_discovery_ip_enabled()) {
72 this->subscribe(
73 "esphome/discover", [this](const std::string &topic, const std::string &payload) { this->send_device_info_(); },
74 2);
75
76 std::string topic = "esphome/ping/";
77 topic.append(App.get_name());
78 this->subscribe(
79 topic, [this](const std::string &topic, const std::string &payload) { this->send_device_info_(); }, 2);
80 }
81
82 if (this->enable_on_boot_) {
83 this->enable();
84 }
85}
86
88 if (!this->is_connected() or !this->is_discovery_ip_enabled()) {
89 return;
90 }
91 std::string topic = "esphome/discover/";
92 topic.append(App.get_name());
93
94 this->publish_json(
95 topic,
96 [](JsonObject root) {
97 uint8_t index = 0;
98 for (auto &ip : network::get_ip_addresses()) {
99 if (ip.is_set()) {
100 root["ip" + (index == 0 ? "" : esphome::to_string(index))] = ip.str();
101 index++;
102 }
103 }
104 root["name"] = App.get_name();
105 if (!App.get_friendly_name().empty()) {
106 root["friendly_name"] = App.get_friendly_name();
107 }
108#ifdef USE_API
109 root["port"] = api::global_api_server->get_port();
110#endif
111 root["version"] = ESPHOME_VERSION;
112 root["mac"] = get_mac_address();
113
114#ifdef USE_ESP8266
115 root["platform"] = "ESP8266";
116#endif
117#ifdef USE_ESP32
118 root["platform"] = "ESP32";
119#endif
120#ifdef USE_LIBRETINY
121 root["platform"] = lt_cpu_get_model_name();
122#endif
123
124 root["board"] = ESPHOME_BOARD;
125#if defined(USE_WIFI)
126 root["network"] = "wifi";
127#elif defined(USE_ETHERNET)
128 root["network"] = "ethernet";
129#endif
130
131#ifdef ESPHOME_PROJECT_NAME
132 root["project_name"] = ESPHOME_PROJECT_NAME;
133 root["project_version"] = ESPHOME_PROJECT_VERSION;
134#endif // ESPHOME_PROJECT_NAME
135
136#ifdef USE_DASHBOARD_IMPORT
137 root["package_import_url"] = dashboard_import::get_package_import_url();
138#endif
139
140#ifdef USE_API_NOISE
141 if (api::global_api_server->get_noise_ctx()->has_psk()) {
142 root["api_encryption"] = "Noise_NNpsk0_25519_ChaChaPoly_SHA256";
143 } else {
144 root["api_encryption_supported"] = "Noise_NNpsk0_25519_ChaChaPoly_SHA256";
145 }
146#endif
147 },
148 2, this->discovery_info_.retain);
149}
150
152 ESP_LOGCONFIG(TAG,
153 "MQTT:\n"
154 " Server Address: %s:%u (%s)\n"
155 " Username: " LOG_SECRET("'%s'") "\n"
156 " Client ID: " LOG_SECRET("'%s'") "\n"
157 " Clean Session: %s",
158 this->credentials_.address.c_str(), this->credentials_.port, this->ip_.str().c_str(),
159 this->credentials_.username.c_str(), this->credentials_.client_id.c_str(),
160 YESNO(this->credentials_.clean_session));
161 if (this->is_discovery_ip_enabled()) {
162 ESP_LOGCONFIG(TAG, " Discovery IP enabled");
163 }
164 if (!this->discovery_info_.prefix.empty()) {
165 ESP_LOGCONFIG(TAG,
166 " Discovery prefix: '%s'\n"
167 " Discovery retain: %s",
168 this->discovery_info_.prefix.c_str(), YESNO(this->discovery_info_.retain));
169 }
170 ESP_LOGCONFIG(TAG, " Topic Prefix: '%s'", this->topic_prefix_.c_str());
171 if (!this->log_message_.topic.empty()) {
172 ESP_LOGCONFIG(TAG, " Log Topic: '%s'", this->log_message_.topic.c_str());
173 }
174 if (!this->availability_.topic.empty()) {
175 ESP_LOGCONFIG(TAG, " Availability: '%s'", this->availability_.topic.c_str());
176 }
177}
179 return network::is_disabled() || this->state_ == MQTT_CLIENT_DISABLED || this->is_connected();
180}
181
183 for (auto &subscription : this->subscriptions_) {
184 subscription.subscribed = false;
185 subscription.resubscribe_timeout = 0;
186 }
187
188 this->status_set_warning();
189 this->dns_resolve_error_ = false;
190 this->dns_resolved_ = false;
191 ip_addr_t addr;
192#if USE_NETWORK_IPV6
193 err_t err = dns_gethostbyname_addrtype(this->credentials_.address.c_str(), &addr,
194 MQTTClientComponent::dns_found_callback, this, LWIP_DNS_ADDRTYPE_IPV6_IPV4);
195#else
196 err_t err = dns_gethostbyname_addrtype(this->credentials_.address.c_str(), &addr,
197 MQTTClientComponent::dns_found_callback, this, LWIP_DNS_ADDRTYPE_IPV4);
198#endif /* USE_NETWORK_IPV6 */
199 switch (err) {
200 case ERR_OK: {
201 // Got IP immediately
202 this->dns_resolved_ = true;
203 this->ip_ = network::IPAddress(&addr);
204 this->start_connect_();
205 return;
206 }
207 case ERR_INPROGRESS: {
208 // wait for callback
209 ESP_LOGD(TAG, "Resolving broker IP address");
210 break;
211 }
212 default:
213 case ERR_ARG: {
214 // error
215 ESP_LOGW(TAG, "Error resolving broker IP address: %d", err);
216 break;
217 }
218 }
219
221 this->connect_begin_ = millis();
222}
224 if (!this->dns_resolved_ && millis() - this->connect_begin_ > 20000) {
225 this->dns_resolve_error_ = true;
226 }
227
228 if (this->dns_resolve_error_) {
229 ESP_LOGW(TAG, "Couldn't resolve IP address for '%s'", this->credentials_.address.c_str());
231 return;
232 }
233
234 if (!this->dns_resolved_) {
235 return;
236 }
237
238 ESP_LOGD(TAG, "Resolved broker IP address to %s", this->ip_.str().c_str());
239 this->start_connect_();
240}
241#if defined(USE_ESP8266) && LWIP_VERSION_MAJOR == 1
242void MQTTClientComponent::dns_found_callback(const char *name, ip_addr_t *ipaddr, void *callback_arg) {
243#else
244void MQTTClientComponent::dns_found_callback(const char *name, const ip_addr_t *ipaddr, void *callback_arg) {
245#endif
246 auto *a_this = (MQTTClientComponent *) callback_arg;
247 if (ipaddr == nullptr) {
248 a_this->dns_resolve_error_ = true;
249 } else {
250 a_this->ip_ = network::IPAddress(ipaddr);
251 a_this->dns_resolved_ = true;
252 }
253}
254
257 return;
258
259 ESP_LOGI(TAG, "Connecting");
260 // Force disconnect first
262
265 const char *username = nullptr;
266 if (!this->credentials_.username.empty())
267 username = this->credentials_.username.c_str();
268 const char *password = nullptr;
269 if (!this->credentials_.password.empty())
270 password = this->credentials_.password.c_str();
271
272 this->mqtt_backend_.set_credentials(username, password);
273
274 this->mqtt_backend_.set_server(this->credentials_.address.c_str(), this->credentials_.port);
275 if (!this->last_will_.topic.empty()) {
276 this->mqtt_backend_.set_will(this->last_will_.topic.c_str(), this->last_will_.qos, this->last_will_.retain,
277 this->last_will_.payload.c_str());
278 }
279
280 this->mqtt_backend_.connect();
282 this->connect_begin_ = millis();
283}
285 return this->state_ == MQTT_CLIENT_CONNECTED && this->mqtt_backend_.connected();
286}
287
289 if (!this->mqtt_backend_.connected()) {
290 if (millis() - this->connect_begin_ > 60000) {
292 this->start_dnslookup_();
293 }
294 return;
295 }
296
298 this->sent_birth_message_ = false;
299 this->status_clear_warning();
300 ESP_LOGI(TAG, "Connected");
301 // MQTT Client needs some time to be fully set up.
302 delay(100); // NOLINT
303
305 this->send_device_info_();
306
307 for (MQTTComponent *component : this->children_)
308 component->schedule_resend_state();
309}
310
312 // Call the backend loop first
314
315 if (this->disconnect_reason_.has_value()) {
316 const LogString *reason_s;
317 switch (*this->disconnect_reason_) {
319 reason_s = LOG_STR("TCP disconnected");
320 break;
322 reason_s = LOG_STR("Unacceptable Protocol Version");
323 break;
325 reason_s = LOG_STR("Identifier Rejected");
326 break;
328 reason_s = LOG_STR("Server Unavailable");
329 break;
331 reason_s = LOG_STR("Malformed Credentials");
332 break;
334 reason_s = LOG_STR("Not Authorized");
335 break;
337 reason_s = LOG_STR("Not Enough Space");
338 break;
340 reason_s = LOG_STR("TLS Bad Fingerprint");
341 break;
342 default:
343 reason_s = LOG_STR("Unknown");
344 break;
345 }
346 if (!network::is_connected()) {
347 reason_s = LOG_STR("WiFi disconnected");
348 }
349 ESP_LOGW(TAG, "Disconnected: %s", LOG_STR_ARG(reason_s));
351 }
352
353 const uint32_t now = App.get_loop_component_start_time();
354
355 switch (this->state_) {
357 return; // Return to avoid a reboot when disabled
359 if (now - this->connect_begin_ > 5000) {
360 this->start_dnslookup_();
361 }
362 break;
364 this->check_dnslookup_();
365 break;
367 this->check_connected();
368 break;
370 if (!this->mqtt_backend_.connected()) {
372 ESP_LOGW(TAG, "Lost client connection");
373 this->start_dnslookup_();
374 } else {
375 if (!this->birth_message_.topic.empty() && !this->sent_birth_message_) {
376 this->sent_birth_message_ = this->publish(this->birth_message_);
377 }
378
379 this->last_connected_ = now;
381 }
382 break;
383 }
384
385 if (millis() - this->last_connected_ > this->reboot_timeout_ && this->reboot_timeout_ != 0) {
386 ESP_LOGE(TAG, "Can't connect; restarting");
387 App.reboot();
388 }
389}
391
392// Subscribe
393bool MQTTClientComponent::subscribe_(const char *topic, uint8_t qos) {
394 if (!this->is_connected())
395 return false;
396
397 bool ret = this->mqtt_backend_.subscribe(topic, qos);
398 yield();
399
400 if (ret) {
401 ESP_LOGV(TAG, "subscribe(topic='%s')", topic);
402 } else {
403 delay(5);
404 ESP_LOGV(TAG, "Subscribe failed for topic='%s'. Will retry", topic);
405 this->status_momentary_warning("subscribe", 1000);
406 }
407 return ret != 0;
408}
409void MQTTClientComponent::resubscribe_subscription_(MQTTSubscription *sub) {
410 if (sub->subscribed)
411 return;
412
413 const uint32_t now = millis();
414 bool do_resub = sub->resubscribe_timeout == 0 || now - sub->resubscribe_timeout > 1000;
415
416 if (do_resub) {
417 sub->subscribed = this->subscribe_(sub->topic.c_str(), sub->qos);
418 sub->resubscribe_timeout = now;
419 }
420}
422 for (auto &subscription : this->subscriptions_) {
423 this->resubscribe_subscription_(&subscription);
424 }
425}
426
427void MQTTClientComponent::subscribe(const std::string &topic, mqtt_callback_t callback, uint8_t qos) {
428 MQTTSubscription subscription{
429 .topic = topic,
430 .qos = qos,
431 .callback = std::move(callback),
432 .subscribed = false,
433 .resubscribe_timeout = 0,
434 };
435 this->resubscribe_subscription_(&subscription);
436 this->subscriptions_.push_back(subscription);
437}
438
439void MQTTClientComponent::subscribe_json(const std::string &topic, const mqtt_json_callback_t &callback, uint8_t qos) {
440 auto f = [callback](const std::string &topic, const std::string &payload) {
441 json::parse_json(payload, [topic, callback](JsonObject root) -> bool {
442 callback(topic, root);
443 return true;
444 });
445 };
446 MQTTSubscription subscription{
447 .topic = topic,
448 .qos = qos,
449 .callback = f,
450 .subscribed = false,
451 .resubscribe_timeout = 0,
452 };
453 this->resubscribe_subscription_(&subscription);
454 this->subscriptions_.push_back(subscription);
455}
456
457void MQTTClientComponent::unsubscribe(const std::string &topic) {
458 bool ret = this->mqtt_backend_.unsubscribe(topic.c_str());
459 yield();
460 if (ret) {
461 ESP_LOGV(TAG, "unsubscribe(topic='%s')", topic.c_str());
462 } else {
463 delay(5);
464 ESP_LOGV(TAG, "Unsubscribe failed for topic='%s'.", topic.c_str());
465 this->status_momentary_warning("unsubscribe", 1000);
466 }
467
468 auto it = subscriptions_.begin();
469 while (it != subscriptions_.end()) {
470 if (it->topic == topic) {
471 it = subscriptions_.erase(it);
472 } else {
473 ++it;
474 }
475 }
476}
477
478// Publish
479bool MQTTClientComponent::publish(const std::string &topic, const std::string &payload, uint8_t qos, bool retain) {
480 return this->publish(topic, payload.data(), payload.size(), qos, retain);
481}
482
483bool MQTTClientComponent::publish(const std::string &topic, const char *payload, size_t payload_length, uint8_t qos,
484 bool retain) {
485 return publish({.topic = topic, .payload = payload, .qos = qos, .retain = retain});
486}
487
488bool MQTTClientComponent::publish(const MQTTMessage &message) {
489 if (!this->is_connected()) {
490 // critical components will re-transmit their messages
491 return false;
492 }
493 bool logging_topic = this->log_message_.topic == message.topic;
494 bool ret = this->mqtt_backend_.publish(message);
495 delay(0);
496 if (!ret && !logging_topic && this->is_connected()) {
497 delay(0);
498 ret = this->mqtt_backend_.publish(message);
499 delay(0);
500 }
501
502 if (!logging_topic) {
503 if (ret) {
504 ESP_LOGV(TAG, "Publish(topic='%s' payload='%s' retain=%d qos=%d)", message.topic.c_str(), message.payload.c_str(),
505 message.retain, message.qos);
506 } else {
507 ESP_LOGV(TAG, "Publish failed for topic='%s' (len=%u). Will retry", message.topic.c_str(),
508 message.payload.length());
509 this->status_momentary_warning("publish", 1000);
510 }
511 }
512 return ret != 0;
513}
514bool MQTTClientComponent::publish_json(const std::string &topic, const json::json_build_t &f, uint8_t qos,
515 bool retain) {
516 std::string message = json::build_json(f);
517 return this->publish(topic, message, qos, retain);
518}
519
521 if (this->state_ != MQTT_CLIENT_DISABLED)
522 return;
523 ESP_LOGD(TAG, "Enabling");
525 this->last_connected_ = millis();
526 this->start_dnslookup_();
527}
528
530 if (this->state_ == MQTT_CLIENT_DISABLED)
531 return;
532 ESP_LOGD(TAG, "Disabling");
534 this->on_shutdown();
535}
536
548static bool topic_match(const char *message, const char *subscription, bool is_normal, bool past_separator) {
549 // Reached end of both strings at the same time, this means we have a successful match
550 if (*message == '\0' && *subscription == '\0')
551 return true;
552
553 // Either the message or the subscribe are at the end. This means they don't match.
554 if (*message == '\0' || *subscription == '\0')
555 return false;
556
557 bool do_wildcards = is_normal || past_separator;
558
559 if (*subscription == '+' && do_wildcards) {
560 // single level wildcard
561 // consume + from subscription
562 subscription++;
563 // consume everything from message until '/' found or end of string
564 while (*message != '\0' && *message != '/') {
565 message++;
566 }
567 // after this, both pointers will point to a '/' or to the end of the string
568
569 return topic_match(message, subscription, is_normal, true);
570 }
571
572 if (*subscription == '#' && do_wildcards) {
573 // multilevel wildcard - MQTT mandates that this must be at end of subscribe topic
574 return true;
575 }
576
577 // this handles '/' and normal characters at the same time.
578 if (*message != *subscription)
579 return false;
580
581 past_separator = past_separator || *subscription == '/';
582
583 // consume characters
584 subscription++;
585 message++;
586
587 return topic_match(message, subscription, is_normal, past_separator);
588}
589
590static bool topic_match(const char *message, const char *subscription) {
591 return topic_match(message, subscription, *message != '\0' && *message != '$', false);
592}
593
594void MQTTClientComponent::on_message(const std::string &topic, const std::string &payload) {
595#ifdef USE_ESP8266
596 // on ESP8266, this is called in lwIP/AsyncTCP task; some components do not like running
597 // from a different task.
598 this->defer([this, topic, payload]() {
599#endif
600 for (auto &subscription : this->subscriptions_) {
601 if (topic_match(topic.c_str(), subscription.topic.c_str()))
602 subscription.callback(topic, payload);
603 }
604#ifdef USE_ESP8266
605 });
606#endif
607}
608
609// Setters
611bool MQTTClientComponent::is_log_message_enabled() const { return !this->log_message_.topic.empty(); }
612void MQTTClientComponent::set_reboot_timeout(uint32_t reboot_timeout) { this->reboot_timeout_ = reboot_timeout; }
613void MQTTClientComponent::register_mqtt_component(MQTTComponent *component) { this->children_.push_back(component); }
614void MQTTClientComponent::set_log_level(int level) { this->log_level_ = level; }
615void MQTTClientComponent::set_keep_alive(uint16_t keep_alive_s) { this->mqtt_backend_.set_keep_alive(keep_alive_s); }
616void MQTTClientComponent::set_log_message_template(MQTTMessage &&message) { this->log_message_ = std::move(message); }
617const MQTTDiscoveryInfo &MQTTClientComponent::get_discovery_info() const { return this->discovery_info_; }
618void MQTTClientComponent::set_topic_prefix(const std::string &topic_prefix, const std::string &check_topic_prefix) {
619 if (App.is_name_add_mac_suffix_enabled() && (topic_prefix == check_topic_prefix)) {
621 } else {
622 this->topic_prefix_ = topic_prefix;
623 }
624}
625const std::string &MQTTClientComponent::get_topic_prefix() const { return this->topic_prefix_; }
626void MQTTClientComponent::set_publish_nan_as_none(bool publish_nan_as_none) {
627 this->publish_nan_as_none_ = publish_nan_as_none;
628}
631 this->birth_message_.topic = "";
633}
635 this->shutdown_message_.topic = "";
637}
638bool MQTTClientComponent::is_discovery_enabled() const { return !this->discovery_info_.prefix.empty(); }
640const Availability &MQTTClientComponent::get_availability() { return this->availability_; }
642 if (this->birth_message_.topic.empty() || this->birth_message_.topic != this->last_will_.topic) {
643 this->availability_.topic = "";
644 return;
645 }
649}
650
651void MQTTClientComponent::set_last_will(MQTTMessage &&message) {
652 this->last_will_ = std::move(message);
654}
655
656void MQTTClientComponent::set_birth_message(MQTTMessage &&message) {
657 this->birth_message_ = std::move(message);
659}
660
661void MQTTClientComponent::set_shutdown_message(MQTTMessage &&message) { this->shutdown_message_ = std::move(message); }
662
663void MQTTClientComponent::set_discovery_info(std::string &&prefix, MQTTDiscoveryUniqueIdGenerator unique_id_generator,
664 MQTTDiscoveryObjectIdGenerator object_id_generator, bool retain,
665 bool discover_ip, bool clean) {
666 this->discovery_info_.prefix = std::move(prefix);
667 this->discovery_info_.discover_ip = discover_ip;
668 this->discovery_info_.unique_id_generator = unique_id_generator;
669 this->discovery_info_.object_id_generator = object_id_generator;
670 this->discovery_info_.retain = retain;
671 this->discovery_info_.clean = clean;
672}
673
675
677 this->discovery_info_ = MQTTDiscoveryInfo{
678 .prefix = "",
679 .retain = false,
680 .discover_ip = false,
681 .clean = false,
682 .unique_id_generator = MQTT_LEGACY_UNIQUE_ID_GENERATOR,
683 .object_id_generator = MQTT_NONE_OBJECT_ID_GENERATOR,
684 };
685}
687 if (!this->shutdown_message_.topic.empty()) {
688 yield();
689 this->publish(this->shutdown_message_);
690 yield();
691 }
693}
694
696 this->mqtt_backend_.set_on_connect(std::forward<mqtt_on_connect_callback_t>(callback));
697}
698
700 this->mqtt_backend_.set_on_disconnect(std::forward<mqtt_on_disconnect_callback_t>(callback));
701}
702
703#if ASYNC_TCP_SSL_ENABLED
704void MQTTClientComponent::add_ssl_fingerprint(const std::array<uint8_t, SHA1_SIZE> &fingerprint) {
705 this->mqtt_backend_.setSecure(true);
706 this->mqtt_backend_.addServerFingerprint(fingerprint.data());
707}
708#endif
709
710MQTTClientComponent *global_mqtt_client = nullptr; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
711
712// MQTTMessageTrigger
713MQTTMessageTrigger::MQTTMessageTrigger(std::string topic) : topic_(std::move(topic)) {}
714void MQTTMessageTrigger::set_qos(uint8_t qos) { this->qos_ = qos; }
715void MQTTMessageTrigger::set_payload(const std::string &payload) { this->payload_ = payload; }
716void MQTTMessageTrigger::setup() {
718 this->topic_,
719 [this](const std::string &topic, const std::string &payload) {
720 if (this->payload_.has_value() && payload != *this->payload_) {
721 return;
722 }
723
724 this->trigger(payload);
725 },
726 this->qos_);
727}
728void MQTTMessageTrigger::dump_config() {
729 ESP_LOGCONFIG(TAG,
730 "MQTT Message Trigger:\n"
731 " Topic: '%s'\n"
732 " QoS: %u",
733 this->topic_.c_str(), this->qos_);
734}
735float MQTTMessageTrigger::get_setup_priority() const { return setup_priority::AFTER_CONNECTION; }
736
737} // namespace mqtt
738} // namespace esphome
739
740#endif // USE_MQTT
const std::string & get_friendly_name() const
Get the friendly name of this Application set by pre_setup().
bool is_name_add_mac_suffix_enabled() const
const std::string & get_name() const
Get the name of this Application set by pre_setup().
uint32_t IRAM_ATTR HOT get_loop_component_start_time() const
Get the cached time in milliseconds from when the current component started its loop execution.
void status_momentary_warning(const std::string &name, uint32_t length=5000)
void status_set_warning(const char *message="unspecified")
void defer(const std::string &name, std::function< void()> &&f)
Defer a callback to the next loop() call.
void status_clear_warning()
uint16_t get_port() const
void add_on_log_callback(std::function< void(int, const char *, const char *)> &&callback)
Register a callback that will be called for every log message sent.
Definition logger.cpp:204
void set_keep_alive(uint16_t keep_alive) final
void set_on_message(std::function< on_message_callback_t > &&callback) final
void set_client_id(const char *client_id) final
void set_on_connect(std::function< on_connect_callback_t > &&callback) final
void set_will(const char *topic, uint8_t qos, bool retain, const char *payload) final
bool subscribe(const char *topic, uint8_t qos) final
void set_server(network::IPAddress ip, uint16_t port) final
bool publish(const char *topic, const char *payload, size_t length, uint8_t qos, bool retain) final
void set_clean_session(bool clean_session) final
bool unsubscribe(const char *topic) final
void set_on_disconnect(std::function< on_disconnect_callback_t > &&callback) final
void set_credentials(const char *username, const char *password) final
void set_birth_message(MQTTMessage &&message)
Set the birth message.
void start_connect_()
Reconnect to the MQTT broker if not already connected.
void setup() override
Setup the MQTT client, registering a bunch of callbacks and attempting to connect.
void disable_discovery()
Globally disable Home Assistant discovery.
void recalculate_availability_()
Re-calculate the availability property.
void set_discovery_info(std::string &&prefix, MQTTDiscoveryUniqueIdGenerator unique_id_generator, MQTTDiscoveryObjectIdGenerator object_id_generator, bool retain, bool discover_ip, bool clean=false)
Set the Home Assistant discovery info.
void set_reboot_timeout(uint32_t reboot_timeout)
float get_setup_priority() const override
MQTT client setup priority.
void disable_log_message()
Get the topic used for logging. Defaults to "<topic_prefix>/debug" and the value is cached for speed.
const std::string & get_topic_prefix() const
Get the topic prefix of this device, using default if necessary.
void subscribe_json(const std::string &topic, const mqtt_json_callback_t &callback, uint8_t qos=0)
Subscribe to a MQTT topic and automatically parse JSON payload.
void register_mqtt_component(MQTTComponent *component)
void set_last_will(MQTTMessage &&message)
Set the last will testament message.
bool publish(const MQTTMessage &message)
Publish a MQTTMessage.
const MQTTDiscoveryInfo & get_discovery_info() const
Get Home Assistant discovery info.
void add_ssl_fingerprint(const std::array< uint8_t, SHA1_SIZE > &fingerprint)
Add a SSL fingerprint to use for TCP SSL connections to the MQTT broker.
void disable_birth_message()
Remove the birth message.
static void dns_found_callback(const char *name, ip_addr_t *ipaddr, void *callback_arg)
void subscribe(const std::string &topic, mqtt_callback_t callback, uint8_t qos=0)
Subscribe to an MQTT topic and call callback when a message is received.
MQTTMessage last_will_
The last will message.
void set_topic_prefix(const std::string &topic_prefix, const std::string &check_topic_prefix)
Set the topic prefix that will be prepended to all topics together with "/".
void set_shutdown_message(MQTTMessage &&message)
MQTTMessage birth_message_
The birth message (e.g.
std::vector< MQTTComponent * > children_
void set_on_connect(mqtt_on_connect_callback_t &&callback)
optional< MQTTClientDisconnectReason > disconnect_reason_
void unsubscribe(const std::string &topic)
Unsubscribe from an MQTT topic.
void set_publish_nan_as_none(bool publish_nan_as_none)
void on_message(const std::string &topic, const std::string &payload)
void set_log_message_template(MQTTMessage &&message)
Manually set the topic used for logging.
void resubscribe_subscription_(MQTTSubscription *sub)
void set_on_disconnect(mqtt_on_disconnect_callback_t &&callback)
bool subscribe_(const char *topic, uint8_t qos)
const Availability & get_availability()
std::vector< MQTTSubscription > subscriptions_
bool publish_json(const std::string &topic, const json::json_build_t &f, uint8_t qos=0, bool retain=false)
Construct and send a JSON MQTT message.
void disable_last_will()
Remove the last will testament message.
void set_keep_alive(uint16_t keep_alive_s)
Set the keep alive time in seconds, every 0.7*keep_alive a ping will be sent.
void loop() override
Reconnect if required.
MQTTDiscoveryInfo discovery_info_
The discovery info options for Home Assistant.
Availability availability_
Caches availability.
MQTTMessageTrigger(std::string topic)
bool has_value() const
Definition optional.h:87
in_addr ip_addr_t
Definition ip_address.h:22
APIServer * global_api_server
std::function< void(JsonObject)> json_build_t
Callback function typedef for building JsonObjects.
Definition json_util.h:20
bool parse_json(const std::string &data, const json_parse_t &f)
Parse a JSON string and run the provided json parse function if it's valid.
Definition json_util.cpp:46
std::string build_json(const json_build_t &f)
Build a JSON string with the provided json build function.
Definition json_util.cpp:12
Logger * global_logger
Definition logger.cpp:242
std::function< MQTTBackend::on_disconnect_callback_t > mqtt_on_disconnect_callback_t
Definition mqtt_client.h:29
MQTTDiscoveryObjectIdGenerator
available discovery object_id generators
Definition mqtt_client.h:71
@ MQTT_NONE_OBJECT_ID_GENERATOR
Definition mqtt_client.h:72
MQTTDiscoveryUniqueIdGenerator
available discovery unique_id generators
Definition mqtt_client.h:65
@ MQTT_LEGACY_UNIQUE_ID_GENERATOR
Definition mqtt_client.h:66
std::function< void(const std::string &, JsonObject)> mqtt_json_callback_t
Definition mqtt_client.h:36
std::function< void(const std::string &, const std::string &)> mqtt_callback_t
Callback for MQTT subscriptions.
Definition mqtt_client.h:35
MQTTClientComponent * global_mqtt_client
@ MQTT_CLIENT_DISCONNECTED
Definition mqtt_client.h:91
@ MQTT_CLIENT_RESOLVING_ADDRESS
Definition mqtt_client.h:92
std::function< MQTTBackend::on_connect_callback_t > mqtt_on_connect_callback_t
Callback for MQTT events.
Definition mqtt_client.h:28
bool is_connected()
Return whether the node is connected to the network (through wifi, eth, ...)
Definition util.cpp:19
network::IPAddresses get_ip_addresses()
Definition util.cpp:49
bool is_disabled()
Return whether the network is disabled (only wifi for now)
Definition util.cpp:41
const float AFTER_WIFI
For components that should be initialized after WiFi is connected.
Definition component.cpp:27
const char *const TAG
Definition spi.cpp:8
Providing packet encoding functions for exchanging data with a remote host.
Definition a01nyub.cpp:7
std::string str_sanitize(const std::string &str)
Sanitizes the input string by removing all characters but alphanumerics, dashes and underscores.
Definition helpers.cpp:299
std::string size_t len
Definition helpers.h:302
void IRAM_ATTR HOT yield()
Definition core.cpp:27
std::string to_string(int value)
Definition helpers.cpp:82
void IRAM_ATTR HOT delay(uint32_t ms)
Definition core.cpp:29
uint32_t IRAM_ATTR HOT millis()
Definition core.cpp:28
std::string get_mac_address()
Get the device MAC address as a string, in lowercase hex notation.
Definition helpers.cpp:726
Application App
Global storage of Application pointer - only one Application can exist.
std::string payload_not_available
Definition mqtt_client.h:61
std::string topic
Empty means disabled.
Definition mqtt_client.h:59
std::string address
The address of the server without port number.
Definition mqtt_client.h:49
bool clean_session
Whether the session will be cleaned or remembered between connects.
Definition mqtt_client.h:54
std::string client_id
The client ID. Will automatically be truncated to 23 characters.
Definition mqtt_client.h:53
MQTTDiscoveryUniqueIdGenerator unique_id_generator
Definition mqtt_client.h:85
bool discover_ip
Enable the Home Assistant device discovery.
Definition mqtt_client.h:83
std::string prefix
The Home Assistant discovery prefix. Empty means disabled.
Definition mqtt_client.h:81
MQTTDiscoveryObjectIdGenerator object_id_generator
Definition mqtt_client.h:86
bool retain
Whether to retain discovery messages.
Definition mqtt_client.h:82
uint8_t qos
QoS. Only for last will testaments.
std::string str() const
Definition ip_address.h:52