esphome 2024.12.4__py3-none-any.whl → 2025.2.0b2__py3-none-any.whl

esphome/components/nextion/nextion.h

@@ -856,76 +856,6 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    */
   void set_backlight_brightness(float brightness);
 
-  /**
-   * Set the touch sleep timeout of the display.
-   * @param timeout Timeout in seconds.
-   *
-   * Example:
-   * ```cpp
-   * it.set_touch_sleep_timeout(30);
-   * ```
-   *
-   * After 30 seconds the display will go to sleep. Note: the display will only wakeup by a restart or by setting up
-   * `thup`.
-   */
-  void set_touch_sleep_timeout(uint16_t timeout);
-
-  /**
-   * Sets which page Nextion loads when exiting sleep mode. Note this can be set even when Nextion is in sleep mode.
-   * @param page_id The page id, from 0 to the lage page in Nextion. Set 255 (not set to any existing page) to
-   * wakes up to current page.
-   *
-   * Example:
-   * ```cpp
-   * it.set_wake_up_page(2);
-   * ```
-   *
-   * The display will wake up to page 2.
-   */
-  void set_wake_up_page(uint8_t page_id = 255);
-
-  /**
-   * Sets which page Nextion loads when connecting to ESPHome.
-   * @param page_id The page id, from 0 to the lage page in Nextion. Set 255 (not set to any existing page) to
-   * wakes up to current page.
-   *
-   * Example:
-   * ```cpp
-   * it.set_start_up_page(2);
-   * ```
-   *
-   * The display will go to page 2 when it establishes a connection to ESPHome.
-   */
-  void set_start_up_page(uint8_t page_id = 255);
-
-  /**
-   * Sets if Nextion should auto-wake from sleep when touch press occurs.
-   * @param auto_wake True or false. When auto_wake is true and Nextion is in sleep mode,
-   * the first touch will only trigger the auto wake mode and not trigger a Touch Event.
-   *
-   * Example:
-   * ```cpp
-   * it.set_auto_wake_on_touch(true);
-   * ```
-   *
-   * The display will wake up by touch.
-   */
-  void set_auto_wake_on_touch(bool auto_wake);
-
-  /**
-   * Sets if Nextion should exit the active reparse mode before the "connect" command is sent
-   * @param exit_reparse True or false. When exit_reparse is true, the exit reparse command
-   * will be sent before requesting the connection from Nextion.
-   *
-   * Example:
-   * ```cpp
-   * it.set_exit_reparse_on_start(true);
-   * ```
-   *
-   * The display will be requested to leave active reparse mode before setup.
-   */
-  void set_exit_reparse_on_start(bool exit_reparse);
-
   /**
    * Sets whether the Nextion display should skip the connection handshake process.
    * @param skip_handshake True or false. When skip_connection_handshake is true,
@@ -1172,15 +1102,75 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
 
   void update_components_by_prefix(const std::string &prefix);
 
-  void set_touch_sleep_timeout_internal(uint32_t touch_sleep_timeout) {
-    this->touch_sleep_timeout_ = touch_sleep_timeout;
-  }
-  void set_wake_up_page_internal(uint8_t wake_up_page) { this->wake_up_page_ = wake_up_page; }
-  void set_start_up_page_internal(uint8_t start_up_page) { this->start_up_page_ = start_up_page; }
-  void set_auto_wake_on_touch_internal(bool auto_wake_on_touch) { this->auto_wake_on_touch_ = auto_wake_on_touch; }
-  void set_exit_reparse_on_start_internal(bool exit_reparse_on_start) {
-    this->exit_reparse_on_start_ = exit_reparse_on_start;
-  }
+  /**
+   * Set the touch sleep timeout of the display.
+   * @param timeout Timeout in seconds.
+   *
+   * Example:
+   * ```cpp
+   * it.set_touch_sleep_timeout(30);
+   * ```
+   *
+   * After 30 seconds the display will go to sleep. Note: the display will only wakeup by a restart or by setting up
+   * `thup`.
+   */
+  void set_touch_sleep_timeout(uint32_t touch_sleep_timeout);
+
+  /**
+   * Sets which page Nextion loads when exiting sleep mode. Note this can be set even when Nextion is in sleep mode.
+   * @param wake_up_page The page id, from 0 to the lage page in Nextion. Set 255 (not set to any existing page) to
+   * wakes up to current page.
+   *
+   * Example:
+   * ```cpp
+   * it.set_wake_up_page(2);
+   * ```
+   *
+   * The display will wake up to page 2.
+   */
+  void set_wake_up_page(uint8_t wake_up_page = 255);
+
+  /**
+   * Sets which page Nextion loads when connecting to ESPHome.
+   * @param start_up_page The page id, from 0 to the lage page in Nextion. Set 255 (not set to any existing page) to
+   * wakes up to current page.
+   *
+   * Example:
+   * ```cpp
+   * it.set_start_up_page(2);
+   * ```
+   *
+   * The display will go to page 2 when it establishes a connection to ESPHome.
+   */
+  void set_start_up_page(uint8_t start_up_page = 255) { this->start_up_page_ = start_up_page; }
+
+  /**
+   * Sets if Nextion should auto-wake from sleep when touch press occurs.
+   * @param auto_wake_on_touch True or false. When auto_wake is true and Nextion is in sleep mode,
+   * the first touch will only trigger the auto wake mode and not trigger a Touch Event.
+   *
+   * Example:
+   * ```cpp
+   * it.set_auto_wake_on_touch(true);
+   * ```
+   *
+   * The display will wake up by touch.
+   */
+  void set_auto_wake_on_touch(bool auto_wake_on_touch);
+
+  /**
+   * Sets if Nextion should exit the active reparse mode before the "connect" command is sent
+   * @param exit_reparse_on_start True or false. When exit_reparse_on_start is true, the exit reparse command
+   * will be sent before requesting the connection from Nextion.
+   *
+   * Example:
+   * ```cpp
+   * it.set_exit_reparse_on_start(true);
+   * ```
+   *
+   * The display will be requested to leave active reparse mode before setup.
+   */
+  void set_exit_reparse_on_start(bool exit_reparse_on_start) { this->exit_reparse_on_start_ = exit_reparse_on_start; }
 
   /**
    * @brief Retrieves the number of commands pending in the Nextion command queue.
@@ -1217,6 +1207,25 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    */
   bool is_updating() override;
 
+  /**
+   * @brief Check if the Nextion display is successfully connected.
+   *
+   * This method returns whether a successful connection has been established with
+   * the Nextion display. A connection is considered established when:
+   *
+   * - The initial handshake with the display is completed successfully, or
+   * - The handshake is skipped via skip_connection_handshake_ flag
+   *
+   * The connection status is particularly useful when:
+   * - Troubleshooting communication issues
+   * - Ensuring the display is ready before sending commands
+   * - Implementing connection-dependent behaviors
+   *
+   * @return true if the Nextion display is connected and ready to receive commands
+   * @return false if the display is not yet connected or connection was lost
+   */
+  bool is_connected() { return this->is_connected_; }
+
  protected:
   std::deque<NextionQueue *> nextion_queue_;
   std::deque<NextionQueue *> waveform_queue_;
@@ -1315,8 +1324,6 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
 
 #endif  // USE_NEXTION_TFT_UPLOAD
 
-  bool get_is_connected_() { return this->is_connected_; }
-
   bool check_connect_();
 
   std::vector<NextionComponentBase *> touch_;
@@ -1332,7 +1339,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   CallbackManager<void()> buffer_overflow_callback_{};
 
   optional<nextion_writer_t> writer_;
-  float brightness_{1.0};
+  optional<float> brightness_;
 
   std::string device_model_;
   std::string firmware_version_;

esphome/components/nextion/nextion_commands.cpp

@@ -10,19 +10,19 @@ static const char *const TAG = "nextion";
 // Sleep safe commands
 void Nextion::soft_reset() { this->send_command_("rest"); }
 
-void Nextion::set_wake_up_page(uint8_t page_id) {
-  this->add_no_result_to_queue_with_set_internal_("wake_up_page", "wup", page_id, true);
+void Nextion::set_wake_up_page(uint8_t wake_up_page) {
+  this->wake_up_page_ = wake_up_page;
+  this->add_no_result_to_queue_with_set_internal_("wake_up_page", "wup", wake_up_page, true);
 }
 
-void Nextion::set_start_up_page(uint8_t page_id) { this->start_up_page_ = page_id; }
-
-void Nextion::set_touch_sleep_timeout(uint16_t timeout) {
-  if (timeout < 3) {
+void Nextion::set_touch_sleep_timeout(uint32_t touch_sleep_timeout) {
+  if (touch_sleep_timeout < 3) {
     ESP_LOGD(TAG, "Sleep timeout out of bounds, range 3-65535");
     return;
   }
 
-  this->add_no_result_to_queue_with_set_internal_("touch_sleep_timeout", "thsp", timeout, true);
+  this->touch_sleep_timeout_ = touch_sleep_timeout;
+  this->add_no_result_to_queue_with_set_internal_("touch_sleep_timeout", "thsp", touch_sleep_timeout, true);
 }
 
 void Nextion::sleep(bool sleep) {
@@ -54,7 +54,6 @@ bool Nextion::set_protocol_reparse_mode(bool active_mode) {
   this->ignore_is_setup_ = false;
   return all_commands_sent;
 }
-void Nextion::set_exit_reparse_on_start(bool exit_reparse) { this->exit_reparse_on_start_ = exit_reparse; }
 
 // Set Colors - Background
 void Nextion::set_component_background_color(const char *component, uint16_t color) {
@@ -191,8 +190,9 @@ void Nextion::set_backlight_brightness(float brightness) {
   this->add_no_result_to_queue_with_printf_("backlight_brightness", "dim=%d", static_cast<int>(brightness * 100));
 }
 
-void Nextion::set_auto_wake_on_touch(bool auto_wake) {
-  this->add_no_result_to_queue_with_set("auto_wake_on_touch", "thup", auto_wake ? 1 : 0);
+void Nextion::set_auto_wake_on_touch(bool auto_wake_on_touch) {
+  this->auto_wake_on_touch_ = auto_wake_on_touch;
+  this->add_no_result_to_queue_with_set("auto_wake_on_touch", "thup", auto_wake_on_touch ? 1 : 0);
 }
 
 // General Component

esphome/components/ntc/sensor.py

@@ -2,7 +2,7 @@ from math import log
 
 import esphome.config_validation as cv
 import esphome.codegen as cg
-from esphome.components import sensor, resistance_sampler
+from esphome.components import sensor
 from esphome.const import (
     CONF_CALIBRATION,
     CONF_REFERENCE_RESISTANCE,
@@ -15,8 +15,6 @@ from esphome.const import (
     UNIT_CELSIUS,
 )
 
-AUTO_LOAD = ["resistance_sampler"]
-
 ntc_ns = cg.esphome_ns.namespace("ntc")
 NTC = ntc_ns.class_("NTC", cg.Component, sensor.Sensor)
 
@@ -126,7 +124,7 @@ CONFIG_SCHEMA = (
     )
     .extend(
         {
-            cv.Required(CONF_SENSOR): cv.use_id(resistance_sampler.ResistanceSampler),
+            cv.Required(CONF_SENSOR): cv.use_id(sensor.Sensor),
             cv.Required(CONF_CALIBRATION): process_calibration,
         }
     )

esphome/components/online_image/__init__.py

@@ -4,14 +4,18 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components.http_request import CONF_HTTP_REQUEST_ID, HttpRequestComponent
 from esphome.components.image import (
-    CONF_USE_TRANSPARENCY,
-    IMAGE_TYPE,
+    CONF_INVERT_ALPHA,
+    CONF_TRANSPARENCY,
+    IMAGE_SCHEMA,
     Image_,
-    validate_cross_dependencies,
+    get_image_type_enum,
+    get_transparency_enum,
 )
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BUFFER_SIZE,
+    CONF_DITHER,
+    CONF_FILE,
     CONF_FORMAT,
     CONF_ID,
     CONF_ON_ERROR,
@@ -23,7 +27,7 @@ from esphome.const import (
 
 AUTO_LOAD = ["image"]
 DEPENDENCIES = ["display", "http_request"]
-CODEOWNERS = ["@guillempages"]
+CODEOWNERS = ["@guillempages", "@clydebarrow"]
 MULTI_CONF = True
 
 CONF_ON_DOWNLOAD_FINISHED = "on_download_finished"
@@ -35,9 +39,54 @@ online_image_ns = cg.esphome_ns.namespace("online_image")
 
 ImageFormat = online_image_ns.enum("ImageFormat")
 
-FORMAT_PNG = "PNG"
 
-IMAGE_FORMAT = {FORMAT_PNG: ImageFormat.PNG}  # Add new supported formats here
+class Format:
+    def __init__(self, image_type):
+        self.image_type = image_type
+
+    @property
+    def enum(self):
+        return getattr(ImageFormat, self.image_type)
+
+    def actions(self):
+        pass
+
+
+class BMPFormat(Format):
+    def __init__(self):
+        super().__init__("BMP")
+
+    def actions(self):
+        cg.add_define("USE_ONLINE_IMAGE_BMP_SUPPORT")
+
+
+class JPEGFormat(Format):
+    def __init__(self):
+        super().__init__("JPEG")
+
+    def actions(self):
+        cg.add_define("USE_ONLINE_IMAGE_JPEG_SUPPORT")
+        cg.add_library("JPEGDEC", None, "https://github.com/bitbank2/JPEGDEC#ca1e0f2")
+
+
+class PNGFormat(Format):
+    def __init__(self):
+        super().__init__("PNG")
+
+    def actions(self):
+        cg.add_define("USE_ONLINE_IMAGE_PNG_SUPPORT")
+        cg.add_library("pngle", "1.0.2")
+
+
+IMAGE_FORMATS = {
+    x.image_type: x
+    for x in (
+        BMPFormat(),
+        JPEGFormat(),
+        PNGFormat(),
+    )
+}
+IMAGE_FORMATS.update({"JPG": IMAGE_FORMATS["JPEG"]})
 
 OnlineImage = online_image_ns.class_("OnlineImage", cg.PollingComponent, Image_)
 
@@ -57,48 +106,54 @@ DownloadErrorTrigger = online_image_ns.class_(
     "DownloadErrorTrigger", automation.Trigger.template()
 )
 
-ONLINE_IMAGE_SCHEMA = cv.Schema(
-    {
-        cv.Required(CONF_ID): cv.declare_id(OnlineImage),
-        cv.GenerateID(CONF_HTTP_REQUEST_ID): cv.use_id(HttpRequestComponent),
-        #
-        # Common image options
-        #
-        cv.Optional(CONF_RESIZE): cv.dimensions,
-        cv.Optional(CONF_TYPE, default="BINARY"): cv.enum(IMAGE_TYPE, upper=True),
-        # Not setting default here on purpose; the default depends on the image type,
-        # and thus will be set in the "validate_cross_dependencies" validator.
-        cv.Optional(CONF_USE_TRANSPARENCY): cv.boolean,
-        #
-        # Online Image specific options
-        #
-        cv.Required(CONF_URL): cv.url,
-        cv.Required(CONF_FORMAT): cv.enum(IMAGE_FORMAT, upper=True),
-        cv.Optional(CONF_PLACEHOLDER): cv.use_id(Image_),
-        cv.Optional(CONF_BUFFER_SIZE, default=2048): cv.int_range(256, 65536),
-        cv.Optional(CONF_ON_DOWNLOAD_FINISHED): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(DownloadFinishedTrigger),
-            }
-        ),
-        cv.Optional(CONF_ON_ERROR): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(DownloadErrorTrigger),
-            }
-        ),
+
+def remove_options(*options):
+    return {
+        cv.Optional(option): cv.invalid(
+            f"{option} is an invalid option for online_image"
+        )
+        for option in options
     }
-).extend(cv.polling_component_schema("never"))
+
+
+ONLINE_IMAGE_SCHEMA = (
+    IMAGE_SCHEMA.extend(remove_options(CONF_FILE, CONF_INVERT_ALPHA, CONF_DITHER))
+    .extend(
+        {
+            cv.Required(CONF_ID): cv.declare_id(OnlineImage),
+            cv.GenerateID(CONF_HTTP_REQUEST_ID): cv.use_id(HttpRequestComponent),
+            # Online Image specific options
+            cv.Required(CONF_URL): cv.url,
+            cv.Required(CONF_FORMAT): cv.one_of(*IMAGE_FORMATS, upper=True),
+            cv.Optional(CONF_PLACEHOLDER): cv.use_id(Image_),
+            cv.Optional(CONF_BUFFER_SIZE, default=65536): cv.int_range(256, 65536),
+            cv.Optional(CONF_ON_DOWNLOAD_FINISHED): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        DownloadFinishedTrigger
+                    ),
+                }
+            ),
+            cv.Optional(CONF_ON_ERROR): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(DownloadErrorTrigger),
+                }
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("never"))
+)
 
 CONFIG_SCHEMA = cv.Schema(
     cv.All(
         ONLINE_IMAGE_SCHEMA,
-        validate_cross_dependencies,
         cv.require_framework_version(
             # esp8266 not supported yet; if enabled in the future, minimum version of 2.7.0 is needed
             # esp8266_arduino=cv.Version(2, 7, 0),
             esp32_arduino=cv.Version(0, 0, 0),
             esp_idf=cv.Version(4, 0, 0),
             rp2040_arduino=cv.Version(0, 0, 0),
+            host=cv.Version(0, 0, 0),
         ),
     )
 )
@@ -132,29 +187,26 @@ async def online_image_action_to_code(config, action_id, template_arg, args):
 
 
 async def to_code(config):
-    format = config[CONF_FORMAT]
-    if format in [FORMAT_PNG]:
-        cg.add_define("USE_ONLINE_IMAGE_PNG_SUPPORT")
-        cg.add_library("pngle", "1.0.2")
+    image_format = IMAGE_FORMATS[config[CONF_FORMAT]]
+    image_format.actions()
 
     url = config[CONF_URL]
     width, height = config.get(CONF_RESIZE, (0, 0))
-    transparent = config[CONF_USE_TRANSPARENCY]
+    transparent = get_transparency_enum(config[CONF_TRANSPARENCY])
 
     var = cg.new_Pvariable(
         config[CONF_ID],
         url,
         width,
         height,
-        format,
-        config[CONF_TYPE],
+        image_format.enum,
+        get_image_type_enum(config[CONF_TYPE]),
+        transparent,
         config[CONF_BUFFER_SIZE],
     )
     await cg.register_component(var, config)
     await cg.register_parented(var, config[CONF_HTTP_REQUEST_ID])
 
-    cg.add(var.set_transparency(transparent))
-
     if placeholder_id := config.get(CONF_PLACEHOLDER):
         placeholder = await cg.get_variable(placeholder_id)
         cg.add(var.set_placeholder(placeholder))

esphome/components/online_image/bmp_image.cpp

@@ -0,0 +1,101 @@
+#include "bmp_image.h"
+
+#ifdef USE_ONLINE_IMAGE_BMP_SUPPORT
+
+#include "esphome/components/display/display.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace online_image {
+
+static const char *const TAG = "online_image.bmp";
+
+int HOT BmpDecoder::decode(uint8_t *buffer, size_t size) {
+  size_t index = 0;
+  if (this->current_index_ == 0 && index == 0 && size > 14) {
+    /**
+     * BMP file format:
+     * 0-1: Signature (BM)
+     * 2-5: File size
+     * 6-9: Reserved
+     * 10-13: Pixel data offset
+     *
+     * Integer values are stored in little-endian format.
+     */
+
+    // Check if the file is a BMP image
+    if (buffer[0] != 'B' || buffer[1] != 'M') {
+      ESP_LOGE(TAG, "Not a BMP file");
+      return DECODE_ERROR_INVALID_TYPE;
+    }
+
+    this->download_size_ = encode_uint32(buffer[5], buffer[4], buffer[3], buffer[2]);
+    this->data_offset_ = encode_uint32(buffer[13], buffer[12], buffer[11], buffer[10]);
+
+    this->current_index_ = 14;
+    index = 14;
+  }
+  if (this->current_index_ == 14 && index == 14 && size > this->data_offset_) {
+    /**
+     * BMP DIB header:
+     * 14-17: DIB header size
+     * 18-21: Image width
+     * 22-25: Image height
+     * 26-27: Number of color planes
+     * 28-29: Bits per pixel
+     * 30-33: Compression method
+     * 34-37: Image data size
+     * 38-41: Horizontal resolution
+     * 42-45: Vertical resolution
+     * 46-49: Number of colors in the color table
+     */
+
+    this->width_ = encode_uint32(buffer[21], buffer[20], buffer[19], buffer[18]);
+    this->height_ = encode_uint32(buffer[25], buffer[24], buffer[23], buffer[22]);
+    this->bits_per_pixel_ = encode_uint16(buffer[29], buffer[28]);
+    this->compression_method_ = encode_uint32(buffer[33], buffer[32], buffer[31], buffer[30]);
+    this->image_data_size_ = encode_uint32(buffer[37], buffer[36], buffer[35], buffer[34]);
+    this->color_table_entries_ = encode_uint32(buffer[49], buffer[48], buffer[47], buffer[46]);
+
+    switch (this->bits_per_pixel_) {
+      case 1:
+        this->width_bytes_ = (this->width_ % 8 == 0) ? (this->width_ / 8) : (this->width_ / 8 + 1);
+        break;
+      default:
+        ESP_LOGE(TAG, "Unsupported bits per pixel: %d", this->bits_per_pixel_);
+        return DECODE_ERROR_UNSUPPORTED_FORMAT;
+    }
+
+    if (this->compression_method_ != 0) {
+      ESP_LOGE(TAG, "Unsupported compression method: %d", this->compression_method_);
+      return DECODE_ERROR_UNSUPPORTED_FORMAT;
+    }
+
+    if (!this->set_size(this->width_, this->height_)) {
+      return DECODE_ERROR_OUT_OF_MEMORY;
+    }
+    this->current_index_ = this->data_offset_;
+    index = this->data_offset_;
+  }
+  while (index < size) {
+    size_t paint_index = this->current_index_ - this->data_offset_;
+
+    uint8_t current_byte = buffer[index];
+    for (uint8_t i = 0; i < 8; i++) {
+      size_t x = (paint_index * 8) % this->width_ + i;
+      size_t y = (this->height_ - 1) - (paint_index / this->width_bytes_);
+      Color c = (current_byte & (1 << (7 - i))) ? display::COLOR_ON : display::COLOR_OFF;
+      this->draw(x, y, 1, 1, c);
+    }
+    this->current_index_++;
+    index++;
+  }
+  this->decoded_bytes_ += size;
+  return size;
+};
+
+}  // namespace online_image
+}  // namespace esphome
+
+#endif  // USE_ONLINE_IMAGE_BMP_SUPPORT

esphome/components/online_image/bmp_image.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#ifdef USE_ONLINE_IMAGE_BMP_SUPPORT
+
+#include "image_decoder.h"
+
+namespace esphome {
+namespace online_image {
+
+/**
+ * @brief Image decoder specialization for PNG images.
+ */
+class BmpDecoder : public ImageDecoder {
+ public:
+  /**
+   * @brief Construct a new BMP Decoder object.
+   *
+   * @param display The image to decode the stream into.
+   */
+  BmpDecoder(OnlineImage *image) : ImageDecoder(image) {}
+
+  int HOT decode(uint8_t *buffer, size_t size) override;
+
+ protected:
+  size_t current_index_{0};
+  ssize_t width_{0};
+  ssize_t height_{0};
+  uint16_t bits_per_pixel_{0};
+  uint32_t compression_method_{0};
+  uint32_t image_data_size_{0};
+  uint32_t color_table_entries_{0};
+  size_t width_bytes_{0};
+  size_t data_offset_{0};
+};
+
+}  // namespace online_image
+}  // namespace esphome
+
+#endif  // USE_ONLINE_IMAGE_BMP_SUPPORT

esphome/components/online_image/image_decoder.cpp

@@ -8,10 +8,11 @@ namespace online_image {
 
 static const char *const TAG = "online_image.decoder";
 
-void ImageDecoder::set_size(int width, int height) {
-  this->image_->resize_(width, height);
+bool ImageDecoder::set_size(int width, int height) {
+  bool resized = this->image_->resize_(width, height);
   this->x_scale_ = static_cast<double>(this->image_->buffer_width_) / width;
   this->y_scale_ = static_cast<double>(this->image_->buffer_height_) / height;
+  return resized;
 }
 
 void ImageDecoder::draw(int x, int y, int w, int h, const Color &color) {
@@ -24,6 +25,15 @@ void ImageDecoder::draw(int x, int y, int w, int h, const Color &color) {
   }
 }
 
+DownloadBuffer::DownloadBuffer(size_t size) : size_(size) {
+  this->buffer_ = this->allocator_.allocate(size);
+  this->reset();
+  if (!this->buffer_) {
+    ESP_LOGE(TAG, "Initial allocation of download buffer failed!");
+    this->size_ = 0;
+  }
+}
+
 uint8_t *DownloadBuffer::data(size_t offset) {
   if (offset > this->size_) {
     ESP_LOGE(TAG, "Tried to access beyond download buffer bounds!!!");
@@ -40,5 +50,21 @@ size_t DownloadBuffer::read(size_t len) {
   return this->unread_;
 }
 
+size_t DownloadBuffer::resize(size_t size) {
+  if (this->size_ == size) {
+    return size;
+  }
+  this->allocator_.deallocate(this->buffer_, this->size_);
+  this->buffer_ = this->allocator_.allocate(size);
+  this->reset();
+  if (this->buffer_) {
+    this->size_ = size;
+    return size;
+  } else {
+    this->size_ = 0;
+    return 0;
+  }
+}
+
 }  // namespace online_image
 }  // namespace esphome