4 #include <esp_http_server.h> 15 namespace web_server {
17 class ListEntitiesIterator;
19 namespace web_server_idf {
21 #define F(string_literal) (string_literal) 22 #define PGM_P const char * 23 #define strncpy_P strncpy 30 const std::string &
value()
const {
return this->value_; }
44 void addHeader(
const char *
name,
const char *value);
46 virtual const char *get_content_data()
const = 0;
47 virtual size_t get_content_size()
const = 0;
80 void print(
const char *str) { this->content_.append(str); }
81 void print(
const std::string &str) { this->content_.append(str); }
82 void print(
float value);
83 void printf(
const char *fmt, ...)
__attribute__((format(printf, 2, 3)));
92 : AsyncWebServerResponse(req), data_(data), size_(size) {}
94 const char *
get_content_data()
const override {
return reinterpret_cast<const char *
>(this->data_); };
108 http_method
method()
const {
return static_cast<http_method
>(this->req_->method); }
109 std::string url()
const;
110 std::string host()
const;
114 bool authenticate(
const char *username,
const char *password)
const;
116 void requestAuthentication(
const char *realm =
nullptr)
const;
118 void redirect(
const std::string &url);
121 void send(
int code,
const char *content_type =
nullptr,
const char *content =
nullptr);
125 this->init_response_(res, code, content_type);
131 this->init_response_(res, code, content_type);
138 this->init_response_(res, code, content_type);
144 this->init_response_(res, 200, content_type);
149 bool hasParam(
const std::string &
name) {
return this->getParam(name) !=
nullptr; }
154 bool hasArg(
const char *name) {
return this->hasParam(name); }
155 std::string
arg(
const std::string &name) {
156 auto *param = this->getParam(name);
158 return param->value();
163 operator httpd_req_t *()
const {
return this->req_; }
166 bool hasHeader(
const char *name)
const;
171 std::map<std::string, AsyncWebParameter *>
params_;
193 this->handlers_.push_back(handler);
199 httpd_handle_t server_{};
200 static esp_err_t request_handler(httpd_req_t *r);
201 static esp_err_t request_post_handler(httpd_req_t *r);
204 std::function<void(AsyncWebServerRequest *request)> on_not_found_{};
216 size_t len,
bool final) {}
245 : source_(source), message_generator_(message_generator) {}
255 bool try_send_nodefer(
const char *message,
const char *event =
nullptr, uint32_t
id = 0, uint32_t reconnect = 0);
256 void deferrable_send_state(
void *source,
const char *event_type,
message_generator_t *message_generator);
264 void process_deferred_queue_();
265 void process_buffer_();
267 static void destroy(
void *p);
269 httpd_handle_t hd_{};
274 std::string event_buffer_{
""};
282 using connect_handler_t = std::function<void(AsyncEventSourceClient *)>;
290 return request->
method() == HTTP_GET && request->
url() == this->url_;
295 void onConnect(connect_handler_t
cb) { this->on_connect_ = std::move(cb); }
297 void try_send_nodefer(
const char *message,
const char *event =
nullptr, uint32_t
id = 0, uint32_t reconnect = 0);
298 void deferrable_send_state(
void *source,
const char *event_type,
message_generator_t *message_generator);
300 bool empty() {
return this->count() == 0; }
302 size_t count()
const {
return this->sessions_.size(); }
307 connect_handler_t on_connect_{};
317 void addHeader(
const char *
name,
const char *value) { this->headers_.emplace_back(name, value); }
326 std::vector<std::pair<std::string, std::string>>
headers_;
334 #endif // !defined(USE_ESP_IDF) AsyncWebServer(uint16_t port)
http_method method() const
size_t get_content_size() const override
bool hasParam(const std::string &name)
virtual void handleRequest(AsyncWebServerRequest *request)
This class allows users to create a web server with their ESP nodes.
virtual ~AsyncWebServerResponse()
size_t get_content_size() const override
void print(const std::string &str)
AsyncResponseStream * beginResponseStream(const char *content_type)
AsyncWebHandler & addHandler(AsyncWebHandler *handler)
size_t contentLength() const
virtual void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total)
std::unique_ptr< esphome::web_server::ListEntitiesIterator > entities_iterator_
virtual bool canHandle(AsyncWebServerRequest *request)
virtual ~AsyncWebHandler()
const char * get_content_data() const override
const char * get_content_data() const override
AsyncWebServerRequest(httpd_req_t *req)
const std::string & value() const
const char * get_content_data() const override
std::string(esphome::web_server::WebServer *, void *) message_generator_t
virtual bool isRequestHandlerTrivial()
AsyncWebServerResponse(const AsyncWebServerRequest *req)
void onConnect(connect_handler_t cb)
AsyncWebServerResponseProgmem(const AsyncWebServerRequest *req, const uint8_t *data, const size_t size)
const AsyncWebServerRequest * req_
friend class AsyncEventSourceResponse
void print(const char *str)
AsyncWebServerResponse * beginResponse(int code, const char *content_type)
AsyncEventSource * server_
bool hasArg(const char *name)
message_generator_t * message_generator_
const char * get_content_data() const override
virtual void handleUpload(AsyncWebServerRequest *request, const std::string &filename, size_t index, uint8_t *data, size_t len, bool final)
void onNotFound(std::function< void(AsyncWebServerRequest *request)> fn)
std::vector< AsyncWebHandler * > handlers_
AsyncWebServerResponseContent(const AsyncWebServerRequest *req, std::string content)
esphome::web_server::WebServer * web_server_
AsyncWebServerResponseEmpty(const AsyncWebServerRequest *req)
esphome::web_server::WebServer * web_server_
enum esphome::EntityCategory __attribute__
std::map< std::string, AsyncWebParameter * > params_
std::string arg(const std::string &name)
AsyncEventSource(std::string url, esphome::web_server::WebServer *ws)
AsyncWebServerResponse * beginResponse_P(int code, const char *content_type, const uint8_t *data, const size_t data_size)
AsyncWebServerRequest(httpd_req_t *req, std::string post_query)
Implementation of SPI Controller mode.
size_t get_content_size() const override
std::set< AsyncEventSourceResponse * > sessions_
std::vector< DeferredEvent > deferred_queue_
AsyncWebParameter(std::string value)
bool operator==(const DeferredEvent &test) const
DeferredEvent(void *source, message_generator_t *message_generator)
AsyncWebServerResponse * beginResponse(int code, const char *content_type, const std::string &content)
bool canHandle(AsyncWebServerRequest *request) override
AsyncResponseStream(const AsyncWebServerRequest *req)
size_t get_content_size() const override