online_image.h

Go to the documentation of this file.

#pragma once
 
#include "download_buffer.h"
#include "esphome/components/http_request/http_request.h"
#include "esphome/components/runtime_image/runtime_image.h"
#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/core/defines.h"
#include "esphome/core/helpers.h"
 
namespace esphome::online_image {
 
using t_http_codes = enum {
  HTTP_CODE_OK = 200,
  HTTP_CODE_NOT_MODIFIED = 304,
  HTTP_CODE_NOT_FOUND = 404,
};
 
static constexpr size_t READ_CHUNK = 1460;
 
class OnlineImage final : public PollingComponent,
                          public runtime_image::RuntimeImage,
                          public Parented<esphome::http_request::HttpRequestComponent> {
 public:
  OnlineImage(const std::string &url, int width, int height, runtime_image::ImageFormat format, image::ImageType type,
              image::Transparency transparency, image::Image *placeholder, uint32_t buffer_size,
              bool is_big_endian = false);
 
  void update() override;
  void update_if(bool update) {
    if (update)
      this->update();
  }
  void loop() override;
 
  void set_url(const std::string &url) {
    if (this->validate_url_(url)) {
      this->url_ = url;
    }
    this->etag_ = "";
    this->last_modified_ = "";
  }
 
  template<typename V> void add_request_header(const std::string &header, V value) {
    this->request_headers_.push_back(std::pair<std::string, TemplatableValue<std::string>>(header, value));
  }
 
  void release();
 
  template<typename F> void add_on_download_started_callback(F &&callback) {
    this->download_started_callback_.add(std::forward<F>(callback));
  }
  template<typename F> void add_on_finished_callback(F &&callback) {
    this->download_finished_callback_.add(std::forward<F>(callback));
  }
  template<typename F> void add_on_progress_callback(F &&callback) {
    this->download_progress_callback_.add(std::forward<F>(callback));
  }
  template<typename F> void add_on_error_callback(F &&callback) {
    this->download_error_callback_.add(std::forward<F>(callback));
  }
 
 protected:
  bool validate_url_(const std::string &url);
  void end_connection_();
  void finish_download_();
  void loop_stream_();
  void fail_download_();
  void report_progress_(bool force);
 
  CallbackManager<void(bool)> download_finished_callback_{};
  CallbackManager<void()> download_error_callback_{};
  LazyCallbackManager<void()> download_started_callback_{};
  LazyCallbackManager<void(float, size_t)> download_progress_callback_{};
 
  std::shared_ptr<http_request::HttpContainer> downloader_{nullptr};
  DownloadBuffer download_buffer_;
  DownloadSource source_{download_buffer_};
  size_t download_buffer_initial_size_;
 
  std::string url_;
 
  std::vector<std::pair<std::string, TemplatableValue<std::string>>> request_headers_;
 
  std::string etag_;
  std::string last_modified_;
 
  uint32_t start_time_{0};
  uint32_t last_data_time_{0};
  uint32_t last_progress_time_{0};
  bool streaming_{false};       // The decoder reads the download itself, as it arrives
  bool stream_started_{false};  // The decoder has read the headers
};
 
}  // namespace esphome::online_image