online_image.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/components/http_request/http_request.h"
#include "esphome/components/image/image.h"
#include "esphome/core/component.h"
#include "esphome/core/defines.h"
#include "esphome/core/helpers.h"
 
#include "image_decoder.h"
 
namespace esphome {
namespace online_image {
 
using t_http_codes = enum {
  HTTP_CODE_OK = 200,
  HTTP_CODE_NOT_MODIFIED = 304,
  HTTP_CODE_NOT_FOUND = 404,
};
 
enum ImageFormat {
  AUTO,
  JPEG,
  PNG,
  BMP,
};
 
class OnlineImage : public PollingComponent,
                    public image::Image,
                    public Parented<esphome::http_request::HttpRequestComponent> {
 public:
  OnlineImage(const std::string &url, int width, int height, ImageFormat format, image::ImageType type,
              image::Transparency transparency, uint32_t buffer_size);
 
  void draw(int x, int y, display::Display *display, Color color_on, Color color_off) override;
 
  void update() override;
  void loop() override;
  void map_chroma_key(Color &color);
 
  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 set_placeholder(image::Image *placeholder) { this->placeholder_ = placeholder; }
 
  void release();
 
  size_t resize_download_buffer(size_t size) { return this->download_buffer_.resize(size); }
 
  void add_on_finished_callback(std::function<void(bool)> &&callback);
  void add_on_error_callback(std::function<void()> &&callback);
 
 protected:
  bool validate_url_(const std::string &url);
 
  RAMAllocator<uint8_t> allocator_{};
 
  uint32_t get_buffer_size_() const { return get_buffer_size_(this->buffer_width_, this->buffer_height_); }
  int get_buffer_size_(int width, int height) const { return (this->get_bpp() * width + 7u) / 8u * height; }
 
  int get_position_(int x, int y) const { return (x + y * this->buffer_width_) * this->get_bpp() / 8; }
 
  ESPHOME_ALWAYS_INLINE bool is_auto_resize_() const { return this->fixed_width_ == 0 || this->fixed_height_ == 0; }
 
  size_t resize_(int width, int height);
 
  void draw_pixel_(int x, int y, Color color);
 
  void end_connection_();
 
  CallbackManager<void(bool)> download_finished_callback_{};
  CallbackManager<void()> download_error_callback_{};
 
  std::shared_ptr<http_request::HttpContainer> downloader_{nullptr};
  std::unique_ptr<ImageDecoder> decoder_{nullptr};
 
  uint8_t *buffer_;
  DownloadBuffer download_buffer_;
  size_t download_buffer_initial_size_;
 
  const ImageFormat format_;
  image::Image *placeholder_{nullptr};
 
  std::string url_{""};
 
  std::vector<std::pair<std::string, TemplatableValue<std::string> > > request_headers_;
 
  const int fixed_width_;
  const int fixed_height_;
  int buffer_width_;
  int buffer_height_;
  std::string etag_ = "";
  std::string last_modified_ = "";
 
  time_t start_time_;
 
  friend bool ImageDecoder::set_size(int width, int height);
  friend void ImageDecoder::draw(int x, int y, int w, int h, const Color &color);
};
 
template<typename... Ts> class OnlineImageSetUrlAction : public Action<Ts...> {
 public:
  OnlineImageSetUrlAction(OnlineImage *parent) : parent_(parent) {}
  TEMPLATABLE_VALUE(std::string, url)
  void play(Ts... x) override {
    this->parent_->set_url(this->url_.value(x...));
    this->parent_->update();
  }
 
 protected:
  OnlineImage *parent_;
};
 
template<typename... Ts> class OnlineImageReleaseAction : public Action<Ts...> {
 public:
  OnlineImageReleaseAction(OnlineImage *parent) : parent_(parent) {}
  void play(Ts... x) override { this->parent_->release(); }
 
 protected:
  OnlineImage *parent_;
};
 
class DownloadFinishedTrigger : public Trigger<bool> {
 public:
  explicit DownloadFinishedTrigger(OnlineImage *parent) {
    parent->add_on_finished_callback([this](bool cached) { this->trigger(cached); });
  }
};
 
class DownloadErrorTrigger : public Trigger<> {
 public:
  explicit DownloadErrorTrigger(OnlineImage *parent) {
    parent->add_on_error_callback([this]() { this->trigger(); });
  }
};
 
}  // namespace online_image
}  // namespace esphome