esphome 2024.10.3__py3-none-any.whl → 2024.11.0b1__py3-none-any.whl

esphome/components/wifi/wifi_component_esp32_arduino.cpp

@@ -137,8 +137,8 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
   // https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_wifi.html#_CPPv417wifi_sta_config_t
   wifi_config_t conf;
   memset(&conf, 0, sizeof(conf));
-  strncpy(reinterpret_cast<char *>(conf.sta.ssid), ap.get_ssid().c_str(), sizeof(conf.sta.ssid));
-  strncpy(reinterpret_cast<char *>(conf.sta.password), ap.get_password().c_str(), sizeof(conf.sta.password));
+  snprintf(reinterpret_cast<char *>(conf.sta.ssid), sizeof(conf.sta.ssid), "%s", ap.get_ssid().c_str());
+  snprintf(reinterpret_cast<char *>(conf.sta.password), sizeof(conf.sta.password), "%s", ap.get_password().c_str());
 
   // The weakest authmode to accept in the fast scan mode
   if (ap.get_password().empty()) {
@@ -746,7 +746,7 @@ bool WiFiComponent::wifi_start_ap_(const WiFiAP &ap) {
 
   wifi_config_t conf;
   memset(&conf, 0, sizeof(conf));
-  strncpy(reinterpret_cast<char *>(conf.ap.ssid), ap.get_ssid().c_str(), sizeof(conf.ap.ssid));
+  snprintf(reinterpret_cast<char *>(conf.ap.ssid), sizeof(conf.ap.ssid), "%s", ap.get_ssid().c_str());
   conf.ap.channel = ap.get_channel().value_or(1);
   conf.ap.ssid_hidden = ap.get_ssid().size();
   conf.ap.max_connection = 5;
@@ -757,7 +757,7 @@ bool WiFiComponent::wifi_start_ap_(const WiFiAP &ap) {
     *conf.ap.password = 0;
   } else {
     conf.ap.authmode = WIFI_AUTH_WPA2_PSK;
-    strncpy(reinterpret_cast<char *>(conf.ap.password), ap.get_password().c_str(), sizeof(conf.ap.password));
+    snprintf(reinterpret_cast<char *>(conf.ap.password), sizeof(conf.ap.password), "%s", ap.get_password().c_str());
   }
 
   // pairwise cipher of SoftAP, group cipher will be derived using this.

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -236,8 +236,8 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
 
   struct station_config conf {};
   memset(&conf, 0, sizeof(conf));
-  strncpy(reinterpret_cast<char *>(conf.ssid), ap.get_ssid().c_str(), sizeof(conf.ssid));
-  strncpy(reinterpret_cast<char *>(conf.password), ap.get_password().c_str(), sizeof(conf.password));
+  snprintf(reinterpret_cast<char *>(conf.ssid), sizeof(conf.ssid), "%s", ap.get_ssid().c_str());
+  snprintf(reinterpret_cast<char *>(conf.password), sizeof(conf.password), "%s", ap.get_password().c_str());
 
   if (ap.get_bssid().has_value()) {
     conf.bssid_set = 1;
@@ -775,7 +775,7 @@ bool WiFiComponent::wifi_start_ap_(const WiFiAP &ap) {
     return false;
 
   struct softap_config conf {};
-  strncpy(reinterpret_cast<char *>(conf.ssid), ap.get_ssid().c_str(), sizeof(conf.ssid));
+  snprintf(reinterpret_cast<char *>(conf.ssid), sizeof(conf.ssid), "%s", ap.get_ssid().c_str());
   conf.ssid_len = static_cast<uint8>(ap.get_ssid().size());
   conf.channel = ap.get_channel().value_or(1);
   conf.ssid_hidden = ap.get_hidden();
@@ -787,7 +787,7 @@ bool WiFiComponent::wifi_start_ap_(const WiFiAP &ap) {
     *conf.password = 0;
   } else {
     conf.authmode = AUTH_WPA2_PSK;
-    strncpy(reinterpret_cast<char *>(conf.password), ap.get_password().c_str(), sizeof(conf.password));
+    snprintf(reinterpret_cast<char *>(conf.password), sizeof(conf.password), "%s", ap.get_password().c_str());
   }
 
   ETS_UART_INTR_DISABLE();

esphome/components/wifi/wifi_component_esp_idf.cpp

@@ -289,8 +289,8 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
   // https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_wifi.html#_CPPv417wifi_sta_config_t
   wifi_config_t conf;
   memset(&conf, 0, sizeof(conf));
-  strncpy(reinterpret_cast<char *>(conf.sta.ssid), ap.get_ssid().c_str(), sizeof(conf.sta.ssid));
-  strncpy(reinterpret_cast<char *>(conf.sta.password), ap.get_password().c_str(), sizeof(conf.sta.password));
+  snprintf(reinterpret_cast<char *>(conf.sta.ssid), sizeof(conf.sta.ssid), "%s", ap.get_ssid().c_str());
+  snprintf(reinterpret_cast<char *>(conf.sta.password), sizeof(conf.sta.password), "%s", ap.get_password().c_str());
 
   // The weakest authmode to accept in the fast scan mode
   if (ap.get_password().empty()) {

esphome/components/xpt2046/touchscreen/__init__.py

@@ -1,9 +1,8 @@
-import esphome.codegen as cg
-import esphome.config_validation as cv
-
 from esphome import pins
+import esphome.codegen as cg
 from esphome.components import spi, touchscreen
-from esphome.const import CONF_ID, CONF_THRESHOLD, CONF_INTERRUPT_PIN
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INTERRUPT_PIN, CONF_THRESHOLD
 
 CODEOWNERS = ["@numo68", "@nielsnl68"]
 DEPENDENCIES = ["spi"]
@@ -15,13 +14,9 @@ XPT2046Component = XPT2046_ns.class_(
     spi.SPIDevice,
 )
 
-CONF_CALIBRATION_X_MIN = "calibration_x_min"
-CONF_CALIBRATION_X_MAX = "calibration_x_max"
-CONF_CALIBRATION_Y_MIN = "calibration_y_min"
-CONF_CALIBRATION_Y_MAX = "calibration_y_max"
-
 CONFIG_SCHEMA = cv.All(
-    touchscreen.TOUCHSCREEN_SCHEMA.extend(
+    touchscreen.touchscreen_schema(calibration_required=True)
+    .extend(
         cv.Schema(
             {
                 cv.GenerateID(): cv.declare_id(XPT2046Component),
@@ -29,30 +24,10 @@ CONFIG_SCHEMA = cv.All(
                     pins.internal_gpio_input_pin_schema
                 ),
                 cv.Optional(CONF_THRESHOLD, default=400): cv.int_range(min=0, max=4095),
-                cv.Optional(
-                    touchscreen.CONF_CALIBRATION
-                ): touchscreen.calibration_schema(4095),
-                cv.Optional(CONF_CALIBRATION_X_MIN): cv.invalid(
-                    "Deprecated: use the new 'calibration' configuration variable"
-                ),
-                cv.Optional(CONF_CALIBRATION_X_MAX): cv.invalid(
-                    "Deprecated: use the new 'calibration' configuration variable"
-                ),
-                cv.Optional(CONF_CALIBRATION_Y_MIN): cv.invalid(
-                    "Deprecated: use the new 'calibration' configuration variable"
-                ),
-                cv.Optional(CONF_CALIBRATION_Y_MAX): cv.invalid(
-                    "Deprecated: use the new 'calibration' configuration variable"
-                ),
-                cv.Optional(CONF_CALIBRATION_Y_MAX): cv.invalid(
-                    "Deprecated: use the new 'calibration' configuration variable"
-                ),
-                cv.Optional("report_interval"): cv.invalid(
-                    "Deprecated: use the 'update_interval' configuration variable"
-                ),
             },
         )
-    ).extend(spi.spi_device_schema()),
+    )
+    .extend(spi.spi_device_schema()),
 )
 
 

esphome/config_validation.py

@@ -40,6 +40,7 @@ from esphome.const import (
     CONF_SECOND,
     CONF_SETUP_PRIORITY,
     CONF_STATE_TOPIC,
+    CONF_SUBSCRIBE_QOS,
     CONF_TOPIC,
     CONF_TYPE,
     CONF_TYPE_ID,
@@ -1893,9 +1894,10 @@ MQTT_COMPONENT_AVAILABILITY_SCHEMA = Schema(
 
 MQTT_COMPONENT_SCHEMA = Schema(
     {
-        Optional(CONF_QOS): All(requires_component("mqtt"), int_range(min=0, max=2)),
+        Optional(CONF_QOS): All(requires_component("mqtt"), mqtt_qos),
         Optional(CONF_RETAIN): All(requires_component("mqtt"), boolean),
         Optional(CONF_DISCOVERY): All(requires_component("mqtt"), boolean),
+        Optional(CONF_SUBSCRIBE_QOS): All(requires_component("mqtt"), mqtt_qos),
         Optional(CONF_STATE_TOPIC): All(requires_component("mqtt"), publish_topic),
         Optional(CONF_AVAILABILITY): All(
             requires_component("mqtt"), Any(None, MQTT_COMPONENT_AVAILABILITY_SCHEMA)

esphome/const.py

@@ -1,6 +1,6 @@
 """Constants used by esphome."""
 
-__version__ = "2024.10.3"
+__version__ = "2024.11.0b1"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (
@@ -49,6 +49,7 @@ CONF_ADDRESS = "address"
 CONF_ADDRESSABLE_LIGHT_ID = "addressable_light_id"
 CONF_ADVANCED = "advanced"
 CONF_AFTER = "after"
+CONF_ALL = "all"
 CONF_ALLOW_OTHER_USES = "allow_other_uses"
 CONF_ALPHA = "alpha"
 CONF_ALTITUDE = "altitude"
@@ -57,6 +58,7 @@ CONF_AMMONIA = "ammonia"
 CONF_ANALOG = "analog"
 CONF_AND = "and"
 CONF_ANGLE = "angle"
+CONF_ANY = "any"
 CONF_AP = "ap"
 CONF_APPARENT_POWER = "apparent_power"
 CONF_ARDUINO_VERSION = "arduino_version"
@@ -90,6 +92,7 @@ CONF_BINARY_SENSORS = "binary_sensors"
 CONF_BINDKEY = "bindkey"
 CONF_BIRTH_MESSAGE = "birth_message"
 CONF_BIT_DEPTH = "bit_depth"
+CONF_BITS_PER_SAMPLE = "bits_per_sample"
 CONF_BLOCK = "block"
 CONF_BLUE = "blue"
 CONF_BOARD = "board"
@@ -396,8 +399,10 @@ CONF_INCLUDES = "includes"
 CONF_INDEX = "index"
 CONF_INDOOR = "indoor"
 CONF_INFRARED = "infrared"
+CONF_INIT_SEQUENCE = "init_sequence"
 CONF_INITIAL_MODE = "initial_mode"
 CONF_INITIAL_OPTION = "initial_option"
+CONF_INITIAL_STATE = "initial_state"
 CONF_INITIAL_VALUE = "initial_value"
 CONF_INPUT = "input"
 CONF_INTEGRATION_TIME = "integration_time"
@@ -662,6 +667,7 @@ CONF_PMC_1_0 = "pmc_1_0"
 CONF_PMC_10_0 = "pmc_10_0"
 CONF_PMC_2_5 = "pmc_2_5"
 CONF_PMC_4_0 = "pmc_4_0"
+CONF_POLLING_INTERVAL = "polling_interval"
 CONF_PORT = "port"
 CONF_POSITION = "position"
 CONF_POSITION_ACTION = "position_action"
@@ -815,6 +821,7 @@ CONF_STOP = "stop"
 CONF_STOP_ACTION = "stop_action"
 CONF_STORE_BASELINE = "store_baseline"
 CONF_SUBNET = "subnet"
+CONF_SUBSCRIBE_QOS = "subscribe_qos"
 CONF_SUBSTITUTIONS = "substitutions"
 CONF_SUM = "sum"
 CONF_SUPPLEMENTAL_COOLING_ACTION = "supplemental_cooling_action"

esphome/core/defines.h

@@ -44,10 +44,12 @@
 #define USE_LVGL_ANIMIMG
 #define USE_LVGL_BINARY_SENSOR
 #define USE_LVGL_BUTTONMATRIX
+#define USE_LVGL_DROPDOWN
 #define USE_LVGL_FONT
 #define USE_LVGL_IMAGE
 #define USE_LVGL_KEY_LISTENER
 #define USE_LVGL_KEYBOARD
+#define USE_LVGL_ROLLER
 #define USE_LVGL_ROTARY_ENCODER
 #define USE_LVGL_TOUCHSCREEN
 #define USE_MD5
@@ -84,8 +86,6 @@
 #ifdef USE_ARDUINO
 #define USE_CAPTIVE_PORTAL
 #define USE_PROMETHEUS
-#define USE_WEBSERVER
-#define USE_WEBSERVER_PORT 80  // NOLINT
 #define USE_WIFI_WPA2_EAP
 #endif
 
@@ -109,6 +109,8 @@
 #define USE_SPEAKER
 #define USE_SPI
 #define USE_VOICE_ASSISTANT
+#define USE_WEBSERVER
+#define USE_WEBSERVER_PORT 80  // NOLINT
 #define USE_WIFI_11KV_SUPPORT
 
 #ifdef USE_ARDUINO
@@ -145,6 +147,8 @@
 #define USE_SHD_FIRMWARE_DATA \
   {}
 
+#define USE_WEBSERVER
+#define USE_WEBSERVER_PORT 80  // NOLINT
 #endif
 
 #ifdef USE_RP2040
@@ -156,6 +160,8 @@
 
 #ifdef USE_LIBRETINY
 #define USE_SOCKET_IMPL_LWIP_SOCKETS
+#define USE_WEBSERVER
+#define USE_WEBSERVER_PORT 80  // NOLINT
 #endif
 
 #ifdef USE_HOST

esphome/core/helpers.cpp

@@ -10,6 +10,7 @@
 #include <cstdarg>
 #include <cstdio>
 #include <cstring>
+#include <strings.h>
 
 #ifdef USE_HOST
 #ifndef _WIN32
@@ -188,37 +189,39 @@ uint32_t fnv1_hash(const std::string &str) {
   return hash;
 }
 
-uint32_t random_uint32() {
 #ifdef USE_ESP32
-  return esp_random();
+uint32_t random_uint32() { return esp_random(); }
 #elif defined(USE_ESP8266)
-  return os_random();
+uint32_t random_uint32() { return os_random(); }
 #elif defined(USE_RP2040)
+uint32_t random_uint32() {
   uint32_t result = 0;
   for (uint8_t i = 0; i < 32; i++) {
     result <<= 1;
     result |= rosc_hw->randombit;
   }
   return result;
+}
 #elif defined(USE_LIBRETINY)
-  return rand();
+uint32_t random_uint32() { return rand(); }
 #elif defined(USE_HOST)
+uint32_t random_uint32() {
   std::random_device dev;
   std::mt19937 rng(dev());
   std::uniform_int_distribution<uint32_t> dist(0, std::numeric_limits<uint32_t>::max());
   return dist(rng);
-#else
-#error "No random source available for this configuration."
-#endif
 }
+#endif
 float random_float() { return static_cast<float>(random_uint32()) / static_cast<float>(UINT32_MAX); }
-bool random_bytes(uint8_t *data, size_t len) {
 #ifdef USE_ESP32
+bool random_bytes(uint8_t *data, size_t len) {
   esp_fill_random(data, len);
   return true;
+}
 #elif defined(USE_ESP8266)
-  return os_get_random(data, len) == 0;
+bool random_bytes(uint8_t *data, size_t len) { return os_get_random(data, len) == 0; }
 #elif defined(USE_RP2040)
+bool random_bytes(uint8_t *data, size_t len) {
   while (len-- != 0) {
     uint8_t result = 0;
     for (uint8_t i = 0; i < 8; i++) {
@@ -228,10 +231,14 @@ bool random_bytes(uint8_t *data, size_t len) {
     *data++ = result;
   }
   return true;
+}
 #elif defined(USE_LIBRETINY)
+bool random_bytes(uint8_t *data, size_t len) {
   lt_rand_bytes(data, len);
   return true;
+}
 #elif defined(USE_HOST)
+bool random_bytes(uint8_t *data, size_t len) {
   FILE *fp = fopen("/dev/urandom", "r");
   if (fp == nullptr) {
     ESP_LOGW(TAG, "Could not open /dev/urandom, errno=%d", errno);
@@ -244,10 +251,8 @@ bool random_bytes(uint8_t *data, size_t len) {
   }
   fclose(fp);
   return true;
-#else
-#error "No random source available for this configuration."
-#endif
 }
+#endif
 
 // Strings
 
@@ -619,11 +624,13 @@ void hsv_to_rgb(int hue, float saturation, float value, float &red, float &green
 #if defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_HOST)
 // ESP8266 doesn't have mutexes, but that shouldn't be an issue as it's single-core and non-preemptive OS.
 Mutex::Mutex() {}
+Mutex::~Mutex() {}
 void Mutex::lock() {}
 bool Mutex::try_lock() { return true; }
 void Mutex::unlock() {}
 #elif defined(USE_ESP32) || defined(USE_LIBRETINY)
 Mutex::Mutex() { handle_ = xSemaphoreCreateMutex(); }
+Mutex::~Mutex() {}
 void Mutex::lock() { xSemaphoreTake(this->handle_, portMAX_DELAY); }
 bool Mutex::try_lock() { return xSemaphoreTake(this->handle_, 0) == pdTRUE; }
 void Mutex::unlock() { xSemaphoreGive(this->handle_); }
@@ -657,11 +664,13 @@ void HighFrequencyLoopRequester::stop() {
 }
 bool HighFrequencyLoopRequester::is_high_frequency() { return num_requests > 0; }
 
-void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
 #if defined(USE_HOST)
+void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
   static const uint8_t esphome_host_mac_address[6] = USE_ESPHOME_HOST_MAC_ADDRESS;
   memcpy(mac, esphome_host_mac_address, sizeof(esphome_host_mac_address));
+}
 #elif defined(USE_ESP32)
+void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
 #if defined(CONFIG_SOC_IEEE802154_SUPPORTED)
   // When CONFIG_SOC_IEEE802154_SUPPORTED is defined, esp_efuse_mac_get_default
   // returns the 802.15.4 EUI-64 address, so we read directly from eFuse instead.
@@ -677,16 +686,22 @@ void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parame
     esp_efuse_mac_get_default(mac);
   }
 #endif
+}
 #elif defined(USE_ESP8266)
+void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
   wifi_get_macaddr(STATION_IF, mac);
-#elif defined(USE_RP2040) && defined(USE_WIFI)
+}
+#elif defined(USE_RP2040)
+void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
+#ifdef USE_WIFI
   WiFi.macAddress(mac);
+#endif
+}
 #elif defined(USE_LIBRETINY)
+void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
   WiFi.macAddress(mac);
-#else
-// this should be an error, but that messes with CI checks. #error No mac address method defined
-#endif
 }
+#endif
 
 std::string get_mac_address() {
   uint8_t mac[6];

esphome/core/helpers.h

@@ -7,6 +7,7 @@
 #include <string>
 #include <type_traits>
 #include <vector>
+#include <limits>
 
 #include "esphome/core/optional.h"
 
@@ -545,6 +546,7 @@ class Mutex {
  public:
   Mutex();
   Mutex(const Mutex &) = delete;
+  ~Mutex();
   void lock();
   bool try_lock();
   void unlock();
@@ -554,6 +556,8 @@ class Mutex {
  private:
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
   SemaphoreHandle_t handle_;
+#else
+  void *handle_;  // d-pointer to store private data on new platforms
 #endif
 };
 
@@ -651,35 +655,45 @@ void delay_microseconds_safe(uint32_t us);
 /// @name Memory management
 ///@{
 
-/** An STL allocator that uses SPI RAM.
+/** An STL allocator that uses SPI or internal RAM.
+ * Returns `nullptr` in case no memory is available.
  *
- * By setting flags, it can be configured to don't try main memory if SPI RAM is full or unavailable, and to return
- * `nulllptr` instead of aborting when no memory is available.
+ * By setting flags, it can be configured to:
+ * - perform external allocation falling back to main memory if SPI RAM is full or unavailable
+ * - perform external allocation only
+ * - perform internal allocation only
  */
-template<class T> class ExternalRAMAllocator {
+template<class T> class RAMAllocator {
  public:
   using value_type = T;
 
   enum Flags {
-    NONE = 0,
-    REFUSE_INTERNAL = 1 << 0,  ///< Refuse falling back to internal memory when external RAM is full or unavailable.
-    ALLOW_FAILURE = 1 << 1,    ///< Don't abort when memory allocation fails.
+    NONE = 0,                 // Perform external allocation and fall back to internal memory
+    ALLOC_EXTERNAL = 1 << 0,  // Perform external allocation only.
+    ALLOC_INTERNAL = 1 << 1,  // Perform internal allocation only.
+    ALLOW_FAILURE = 1 << 2,   // Does nothing. Kept for compatibility.
   };
 
-  ExternalRAMAllocator() = default;
-  ExternalRAMAllocator(Flags flags) : flags_{flags} {}
-  template<class U> constexpr ExternalRAMAllocator(const ExternalRAMAllocator<U> &other) : flags_{other.flags_} {}
+  RAMAllocator() = default;
+  RAMAllocator(uint8_t flags) : flags_{flags} {}
+  template<class U> constexpr RAMAllocator(const RAMAllocator<U> &other) : flags_{other.flags_} {}
 
   T *allocate(size_t n) {
     size_t size = n * sizeof(T);
     T *ptr = nullptr;
 #ifdef USE_ESP32
-    ptr = static_cast<T *>(heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
-#endif
-    if (ptr == nullptr && (this->flags_ & Flags::REFUSE_INTERNAL) == 0)
+    // External allocation by default or if explicitely requested
+    if ((this->flags_ & Flags::ALLOC_EXTERNAL) || ((this->flags_ & Flags::ALLOC_INTERNAL) == 0)) {
+      ptr = static_cast<T *>(heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT));
+    }
+    // Fallback to internal allocation if explicitely requested or no flag is specified
+    if (ptr == nullptr && ((this->flags_ & Flags::ALLOC_INTERNAL) || (this->flags_ & Flags::ALLOC_EXTERNAL) == 0)) {
       ptr = static_cast<T *>(malloc(size));  // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
-    if (ptr == nullptr && (this->flags_ & Flags::ALLOW_FAILURE) == 0)
-      abort();
+    }
+#else
+    // Ignore ALLOC_EXTERNAL/ALLOC_INTERNAL flags if external allocation is not supported
+    ptr = static_cast<T *>(malloc(size));  // NOLINT(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc)
+#endif
     return ptr;
   }
 
@@ -688,9 +702,11 @@ template<class T> class ExternalRAMAllocator {
   }
 
  private:
-  Flags flags_{Flags::ALLOW_FAILURE};
+  uint8_t flags_{Flags::ALLOW_FAILURE};
 };
 
+template<class T> using ExternalRAMAllocator = RAMAllocator<T>;
+
 /// @}
 
 /// @name Internal functions

esphome/core/ring_buffer.cpp

@@ -46,7 +46,7 @@ size_t RingBuffer::read(void *data, size_t len, TickType_t ticks_to_wait) {
   return bytes_read;
 }
 
-size_t RingBuffer::write(void *data, size_t len) {
+size_t RingBuffer::write(const void *data, size_t len) {
   size_t free = this->free();
   if (free < len) {
     size_t needed = len - free;
@@ -56,7 +56,7 @@ size_t RingBuffer::write(void *data, size_t len) {
   return xStreamBufferSend(this->handle_, data, len, 0);
 }
 
-size_t RingBuffer::write_without_replacement(void *data, size_t len, TickType_t ticks_to_wait) {
+size_t RingBuffer::write_without_replacement(const void *data, size_t len, TickType_t ticks_to_wait) {
   return xStreamBufferSend(this->handle_, data, len, ticks_to_wait);
 }
 

esphome/core/ring_buffer.h

@@ -37,7 +37,7 @@ class RingBuffer {
    * @param len Number of bytes to write
    * @return Number of bytes written
    */
-  size_t write(void *data, size_t len);
+  size_t write(const void *data, size_t len);
 
   /**
    * @brief Writes to the ring buffer without overwriting oldest data.
@@ -50,7 +50,7 @@ class RingBuffer {
    * @param ticks_to_wait Maximum number of FreeRTOS ticks to wait (default: 0)
    * @return Number of bytes written
    */
-  size_t write_without_replacement(void *data, size_t len, TickType_t ticks_to_wait = 0);
+  size_t write_without_replacement(const void *data, size_t len, TickType_t ticks_to_wait = 0);
 
   /**
    * @brief Returns the number of available bytes in the ring buffer.

esphome/dashboard/core.py

@@ -5,10 +5,14 @@ from collections.abc import Coroutine
 import contextlib
 from dataclasses import dataclass
 from functools import partial
+import json
 import logging
+from pathlib import Path
 import threading
 from typing import TYPE_CHECKING, Any, Callable
 
+from esphome.storage_json import ignored_devices_storage_path
+
 from ..zeroconf import DiscoveredImport
 from .dns import DNSCache
 from .entries import DashboardEntries
@@ -20,6 +24,8 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+IGNORED_DEVICES_STORAGE_PATH = "ignored-devices.json"
+
 
 @dataclass
 class Event:
@@ -74,6 +80,7 @@ class ESPHomeDashboard:
         "settings",
         "dns_cache",
         "_background_tasks",
+        "ignored_devices",
     )
 
     def __init__(self) -> None:
@@ -89,12 +96,30 @@ class ESPHomeDashboard:
         self.settings = DashboardSettings()
         self.dns_cache = DNSCache()
         self._background_tasks: set[asyncio.Task] = set()
+        self.ignored_devices: set[str] = set()
 
     async def async_setup(self) -> None:
         """Setup the dashboard."""
         self.loop = asyncio.get_running_loop()
         self.ping_request = asyncio.Event()
         self.entries = DashboardEntries(self)
+        self.load_ignored_devices()
+
+    def load_ignored_devices(self) -> None:
+        storage_path = Path(ignored_devices_storage_path())
+        try:
+            with storage_path.open("r", encoding="utf-8") as f_handle:
+                data = json.load(f_handle)
+                self.ignored_devices = set(data.get("ignored_devices", set()))
+        except FileNotFoundError:
+            pass
+
+    def save_ignored_devices(self) -> None:
+        storage_path = Path(ignored_devices_storage_path())
+        with storage_path.open("w", encoding="utf-8") as f_handle:
+            json.dump(
+                {"ignored_devices": sorted(self.ignored_devices)}, indent=2, fp=f_handle
+            )
 
     async def async_run(self) -> None:
         """Run the dashboard."""

esphome/dashboard/status/mdns.py

@@ -26,7 +26,7 @@ class MDNSStatus:
         self.host_mdns_state: dict[str, bool | None] = {}
         self._loop = asyncio.get_running_loop()
 
-    async def async_resolve_host(self, host_name: str) -> str | None:
+    async def async_resolve_host(self, host_name: str) -> list[str] | None:
         """Resolve a host name to an address in a thread-safe manner."""
         if aiozc := self.aiozc:
             return await aiozc.async_resolve_host(host_name)
@@ -50,13 +50,12 @@ class MDNSStatus:
                 poll_names.setdefault(entry.name, set()).add(entry)
             elif (online := host_mdns_state.get(entry.name, SENTINEL)) != SENTINEL:
                 entries.async_set_state(entry, bool_to_entry_state(online))
-
         if poll_names and self.aiozc:
             results = await asyncio.gather(
                 *(self.aiozc.async_resolve_host(name) for name in poll_names)
             )
-            for name, address in zip(poll_names, results):
-                result = bool(address)
+            for name, address_list in zip(poll_names, results):
+                result = bool(address_list)
                 host_mdns_state[name] = result
                 for entry in poll_names[name]:
                     entries.async_set_state(entry, bool_to_entry_state(result))