Add Captive Portal (#624)

* WIP: Captive Portal

* Updates

* Updates

* Lint

* Fixes

esphome/components/web_server_base/__init__.py

@@ -0,0 +1,24 @@
+import esphome.config_validation as cv
+import esphome.codegen as cg
+from esphome.const import CONF_ID
+from esphome.core import coroutine_with_priority, CORE
+
+DEPENDENCIES = ['network']
+
+web_server_base_ns = cg.esphome_ns.namespace('web_server_base')
+WebServerBase = web_server_base_ns.class_('WebServerBase', cg.Component)
+
+CONF_WEB_SERVER_BASE_ID = 'web_server_base_id'
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_id(WebServerBase),
+})
+
+
+@coroutine_with_priority(65.0)
+def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    yield cg.register_component(var, config)
+
+    if CORE.is_esp32:
+        cg.add_library('FS', None)
+    cg.add_library('ESP Async WebServer', '1.1.1')

esphome/components/web_server_base/web_server_base.cpp

@@ -0,0 +1,96 @@
+#include "web_server_base.h"
+#include "esphome/core/log.h"
+#include "esphome/core/application.h"
+#include <StreamString.h>
+
+#ifdef ARDUINO_ARCH_ESP32
+#include <Update.h>
+#endif
+#ifdef ARDUINO_ARCH_ESP8266
+#include <Updater.h>
+#endif
+
+namespace esphome {
+namespace web_server_base {
+
+static const char *TAG = "web_server_base";
+
+void report_ota_error() {
+  StreamString ss;
+  Update.printError(ss);
+  ESP_LOGW(TAG, "OTA Update failed! Error: %s", ss.c_str());
+}
+
+void OTARequestHandler::handleUpload(AsyncWebServerRequest *request, const String &filename, size_t index,
+                                     uint8_t *data, size_t len, bool final) {
+  bool success;
+  if (index == 0) {
+    ESP_LOGI(TAG, "OTA Update Start: %s", filename.c_str());
+    this->ota_read_length_ = 0;
+#ifdef ARDUINO_ARCH_ESP8266
+    Update.runAsync(true);
+    success = Update.begin((ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000);
+#endif
+#ifdef ARDUINO_ARCH_ESP32
+    if (Update.isRunning())
+      Update.abort();
+    success = Update.begin(UPDATE_SIZE_UNKNOWN, U_FLASH);
+#endif
+    if (!success) {
+      report_ota_error();
+      return;
+    }
+  } else if (Update.hasError()) {
+    // don't spam logs with errors if something failed at start
+    return;
+  }
+
+  success = Update.write(data, len) == len;
+  if (!success) {
+    report_ota_error();
+    return;
+  }
+  this->ota_read_length_ += len;
+
+  const uint32_t now = millis();
+  if (now - this->last_ota_progress_ > 1000) {
+    if (request->contentLength() != 0) {
+      float percentage = (this->ota_read_length_ * 100.0f) / request->contentLength();
+      ESP_LOGD(TAG, "OTA in progress: %0.1f%%", percentage);
+    } else {
+      ESP_LOGD(TAG, "OTA in progress: %u bytes read", this->ota_read_length_);
+    }
+    this->last_ota_progress_ = now;
+  }
+
+  if (final) {
+    if (Update.end(true)) {
+      ESP_LOGI(TAG, "OTA update successful!");
+      this->parent_->set_timeout(100, []() { App.safe_reboot(); });
+    } else {
+      report_ota_error();
+    }
+  }
+}
+void OTARequestHandler::handleRequest(AsyncWebServerRequest *request) {
+  AsyncWebServerResponse *response;
+  if (!Update.hasError()) {
+    response = request->beginResponse(200, "text/plain", "Update Successful!");
+  } else {
+    StreamString ss;
+    ss.print("Update Failed: ");
+    Update.printError(ss);
+    response = request->beginResponse(200, "text/plain", ss);
+  }
+  response->addHeader("Connection", "close");
+  request->send(response);
+}
+
+void WebServerBase::add_ota_handler() { this->add_handler(new OTARequestHandler(this)); }
+float WebServerBase::get_setup_priority() const {
+  // Before WiFi (captive portal)
+  return setup_priority::WIFI + 2.0f;
+}
+
+}  // namespace web_server_base
+}  // namespace esphome

esphome/components/web_server_base/web_server_base.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include "esphome/core/component.h"
+
+#include <ESPAsyncWebServer.h>
+
+namespace esphome {
+namespace web_server_base {
+
+class WebServerBase : public Component {
+ public:
+  void init() {
+    if (this->initialized_) {
+      this->initialized_++;
+      return;
+    }
+    this->server_ = new AsyncWebServer(this->port_);
+    this->server_->begin();
+
+    for (auto *handler : this->handlers_)
+      this->server_->addHandler(handler);
+
+    this->initialized_++;
+  }
+  void deinit() {
+    this->initialized_--;
+    if (this->initialized_ == 0) {
+      delete this->server_;
+      this->server_ = nullptr;
+    }
+  }
+  AsyncWebServer *get_server() const { return server_; }
+  float get_setup_priority() const override;
+
+  void add_handler(AsyncWebHandler *handler) {
+    // remove all handlers
+
+    this->handlers_.push_back(handler);
+    if (this->server_ != nullptr)
+      this->server_->addHandler(handler);
+  }
+
+  void add_ota_handler();
+
+  void set_port(uint16_t port) { port_ = port; }
+  uint16_t get_port() const { return port_; }
+
+ protected:
+  friend class OTARequestHandler;
+
+  int initialized_{0};
+  uint16_t port_{80};
+  AsyncWebServer *server_{nullptr};
+  std::vector<AsyncWebHandler *> handlers_;
+};
+
+class OTARequestHandler : public AsyncWebHandler {
+ public:
+  OTARequestHandler(WebServerBase *parent) : parent_(parent) {}
+  void handleRequest(AsyncWebServerRequest *request) override;
+  void handleUpload(AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len,
+                    bool final) override;
+  bool canHandle(AsyncWebServerRequest *request) override {
+    return request->url() == "/update" && request->method() == HTTP_POST;
+  }
+
+  bool isRequestHandlerTrivial() override { return false; }
+
+ protected:
+  uint32_t last_ota_progress_{0};
+  uint32_t ota_read_length_{0};
+  WebServerBase *parent_;
+};
+
+}  // namespace web_server_base
+}  // namespace esphome