sensesp_app_builder.h

Go to the documentation of this file.

#ifndef SENSESP_APP_BUILDER_H
#define SENSESP_APP_BUILDER_H
 
#include <memory>
 
#include "Arduino.h"
#include "sensesp/sensors/system_info.h"
#include "sensesp/system/valueproducer.h"
#include "sensesp/system/wifi_watchdog.h"
#include "sensesp/transforms/debounce.h"
#include "sensesp_app.h"
#include "sensesp_base_app_builder.h"
 
namespace sensesp {
 
constexpr const char* kDefaultSystemInfoSensorPrefix = "sensorDevice.";
 
class SensESPAppBuilder : public SensESPBaseAppBuilder {
 private:
  String hostname_ = "SensESP";
  String ssid_ = "";
  String password_ = "";
  String sk_server_address_ = "";
  uint16_t sk_server_port_ = 0;
 
 protected:
  std::shared_ptr<SensESPApp> app_;
 
 public:
  SensESPAppBuilder() {
    app_ = std::shared_ptr<SensESPApp>(new SensESPApp());
    app_->set_instance(app_);
  }
  SensESPAppBuilder* set_wifi_client(String ssid, String password) {
    app_->set_ssid(ssid);
    app_->set_wifi_password(password);
    return this;
  }
 
  [[deprecated("Use set_wifi_client instead")]]
  SensESPAppBuilder* set_wifi(String ssid, String password) {
    return set_wifi_client(ssid, password);
  }
 
  SensESPAppBuilder* set_wifi_clients(
      const std::vector<ClientSSIDConfig>& wifi_client_configs) {
    app_->set_wifi_clients(wifi_client_configs);
    return this;
  }
 
  SensESPAppBuilder* set_wifi_access_point(const String& ssid,
                                           const String& password) {
    app_->set_ap_ssid(ssid);
    app_->set_ap_password(password);
    return this;
  }
 
  SensESPAppBuilder* disable_wifi() {
    app_->set_ssid("");
    app_->set_wifi_password("");
    app_->set_ap_ssid("");
    app_->set_ap_password("");
    return this;
  }
 
  template <typename ProvisionerConfigT>
  SensESPAppBuilder* set_ethernet(ProvisionerConfigT config) {
    disable_wifi();
    app_->set_network_provisioner_factory(
        [config]() -> std::shared_ptr<NetworkProvisioner> {
          return std::make_shared<typename ProvisionerConfigT::ProvisionerType>(
              config);
        });
    return this;
  }
 
  SensESPAppBuilder* set_sk_server(String address, uint16_t port) {
    app_->set_sk_server_address(address);
    app_->set_sk_server_port(port);
    return this;
  }
  SensESPAppBuilder* set_hostname(String hostname) override final {
    app_->set_hostname(hostname);
    return this;
  }
  SensESPAppBuilder* set_admin_user(const char* username,
                                    const char* password) {
    app_->set_admin_user(username, password);
    return this;
  }
 
  SensESPAppBuilder* set_system_status_led(
      std::shared_ptr<SystemStatusLed> system_status_led) {
    app_->set_system_status_led(system_status_led);
    return this;
  }
  SensESPAppBuilder* enable_system_hz_sensor(
      String prefix = kDefaultSystemInfoSensorPrefix) {
    auto sensor = std::make_shared<SystemHz>();
    auto vproducer = std::static_pointer_cast<ValueProducer<float>>(sensor);
    // We need to store the sensor in the app so it doesn't get garbage
    // collected.
    app_->system_hz_sensor_ = vproducer;
    connect_system_info_sensor(vproducer, prefix, "systemHz");
    return this;
  }
  SensESPAppBuilder* enable_free_mem_sensor(
      String prefix = kDefaultSystemInfoSensorPrefix) {
    auto sensor = std::make_shared<FreeMem>();
    auto vproducer = std::static_pointer_cast<ValueProducer<uint32_t>>(sensor);
    // We need to store the sensor in the app so it doesn't get garbage
    // collected.
    app_->free_mem_sensor_ = vproducer;
    connect_system_info_sensor(vproducer, prefix, "freeMemory");
    return this;
  }
  SensESPAppBuilder* enable_uptime_sensor(
      String prefix = kDefaultSystemInfoSensorPrefix) {
    auto sensor = std::make_shared<Uptime>();
    auto vproducer = std::static_pointer_cast<ValueProducer<float>>(sensor);
    // We need to store the sensor in the app so it doesn't get garbage
    // collected.
    app_->uptime_sensor_ = vproducer;
    connect_system_info_sensor(vproducer, prefix, "uptime");
    return this;
  }
  SensESPAppBuilder* enable_ip_address_sensor(
      String prefix = kDefaultSystemInfoSensorPrefix) {
    auto sensor = std::make_shared<IPAddrDev>();
    auto vproducer = std::static_pointer_cast<ValueProducer<String>>(sensor);
    // We need to store the sensor in the app so it doesn't get garbage
    // collected.
    app_->ip_address_sensor_ = vproducer;
    connect_system_info_sensor(vproducer, prefix, "ipAddress");
    return this;
  }
  SensESPAppBuilder* enable_wifi_signal_sensor(
      String prefix = kDefaultSystemInfoSensorPrefix) {
    auto sensor = std::make_shared<WiFiSignal>();
    auto vproducer = std::static_pointer_cast<ValueProducer<int>>(sensor);
    // We need to store the sensor in the app so it doesn't get garbage
    // collected.
    app_->wifi_signal_sensor_ = vproducer;
    connect_system_info_sensor(vproducer, prefix, "wifiSignalLevel");
    return this;
  }
 
  SensESPAppBuilder* set_button_pin(int pin) {
    app_->set_button_pin(pin);
    return this;
  }
 
  SensESPAppBuilder* enable_system_info_sensors(
      String prefix = kDefaultSystemInfoSensorPrefix) {
    this->enable_system_hz_sensor(prefix);
    this->enable_free_mem_sensor(prefix);
    this->enable_uptime_sensor(prefix);
    this->enable_ip_address_sensor(prefix);
    this->enable_wifi_signal_sensor(prefix);
    return this;
  }
 
  SensESPAppBuilder* enable_ota(const char* password) {
    app_->enable_ota(password);
    return this;
  }
 
  [[deprecated("Use set_wifi_access_point instead")]]
  SensESPAppBuilder* set_wifi_manager_password(const char* password) {
    app_->set_ap_password(password);
    return this;
  }
 
  SensESPAppBuilder* enable_wifi_watchdog(int timeout_s = 180) {
    if (!WiFiWatchdog::is_valid_timeout_s(timeout_s)) {
      ESP_LOGE(__FILENAME__,
               "WiFi watchdog timeout %d s is out of range [1, %d]; watchdog "
               "not enabled.",
               timeout_s, WiFiWatchdog::kMaxTimeoutS);
      return this;
    }
    if (app_->network_state_producer_) {
      ESP_LOGE(__FILENAME__,
               "enable_wifi_watchdog() must be called before get_app(); "
               "watchdog not enabled.");
      return this;
    }
    app_->wifi_watchdog_timeout_s_ = timeout_s;
    return this;
  }
 
  std::shared_ptr<SensESPApp> get_app() {
    app_ = SensESPApp::get();
    app_->setup();
    return app_;
  }
};
 
}  // namespace sensesp
 
#endif