sensesp_app.h

Go to the documentation of this file.

#ifndef SENSESP_APP_H_
#define SENSESP_APP_H_
 
#include <functional>
 
#include "sensesp/controllers/system_status_controller.h"
#include "sensesp/net/discovery.h"
#include "sensesp/net/http_server.h"
#include "sensesp/net/network_provisioner.h"
#include "sensesp/net/network_state.h"
#include "sensesp/net/networking.h"
#include "sensesp/net/ota.h"
#include "sensesp/net/web/app_command_handler.h"
#include "sensesp/net/web/base_command_handler.h"
#include "sensesp/net/web/config_handler.h"
#include "sensesp/net/web/static_file_handler.h"
#include "sensesp/net/web/ui_button_handler.h"
#include "sensesp/net/wifi_provisioner.h"
#include "sensesp/sensesp_version.h"
#include "sensesp/sensors/sensor.h"
#include "sensesp/signalk/signalk_delta_queue.h"
#include "sensesp/signalk/signalk_ws_client.h"
#include "sensesp/system/button.h"
#include "sensesp/system/log_buffer.h"
#include "sensesp/system/reset_info.h"
#include "sensesp/system/system_status_led.h"
#include "sensesp/ui/status_page_item.h"
#include "sensesp_base_app.h"
 
namespace sensesp {
 
class SensESPApp;
// I'd rather not have this global variable here but many legacy examples
// access it. Use SensESPApp::get() instead.
extern std::shared_ptr<SensESPApp> sensesp_app;
 
class SensESPApp : public SensESPBaseApp {
 public:
  SensESPApp(SensESPApp& other) = delete;
 
  void operator=(const SensESPApp&) = delete;
 
  static std::shared_ptr<SensESPApp> get() {
    if (instance_ == nullptr) {
      instance_ = std::shared_ptr<SensESPApp>(new SensESPApp());
    }
    return std::static_pointer_cast<SensESPApp>(instance_);
  }
 
  virtual bool destroy() override {
    // Drop the global pointer's reference first so the base sees the true
    // outside-user count, then delegate the shared teardown (registry
    // clearing, instance reset) to SensESPBaseApp::destroy().
    sensesp_app = nullptr;
    return SensESPBaseApp::destroy();
  }
 
  // getters for internal members
  std::shared_ptr<SKDeltaQueue> get_sk_delta() { return this->sk_delta_queue_; }
  std::shared_ptr<SystemStatusController> get_system_status_controller() {
    return this->system_status_controller_;
  }
 
  std::shared_ptr<NetworkProvisioner>& get_network_provisioner() {
    return this->network_provisioner_;
  }
 
  std::shared_ptr<WiFiProvisioner>& get_wifi_provisioner() {
    return this->wifi_provisioner_;
  }
 
  std::shared_ptr<NetworkStateProducer> get_network_state_producer() {
    return this->network_state_producer_;
  }
 
  std::shared_ptr<WiFiProvisioner>& get_networking() {
    return this->wifi_provisioner_;
  }
 
  std::shared_ptr<SKWSClient> get_ws_client() { return this->ws_client_; }
 
  void set_network_provisioner_factory(
      std::function<std::shared_ptr<NetworkProvisioner>()> factory) {
    provisioner_factory_ = std::move(factory);
  }
 
 protected:
  SensESPApp() : SensESPBaseApp() {}
 
  // setters for all constructor arguments
 
  const SensESPApp* set_hostname(String hostname) {
    this->SensESPBaseApp::set_hostname(hostname);
    return this;
  }
  const SensESPApp* set_ssid(String ssid) {
    this->ssid_ = ssid;
    return this;
  }
  const SensESPApp* set_wifi_password(String wifi_password) {
    this->wifi_client_password_ = wifi_password;
    return this;
  }
  const SensESPApp* set_wifi_clients(
      const std::vector<ClientSSIDConfig>& wifi_client_configs) {
    this->wifi_client_configs_ = wifi_client_configs;
    return this;
  }
  const SensESPApp* set_ap_ssid(const String& ssid) {
    this->ap_ssid_ = ssid;
    return this;
  }
  const SensESPApp* set_ap_password(const String& password) {
    this->ap_password_ = password;
    return this;
  }
  const SensESPApp* set_sk_server_address(String sk_server_address) {
    this->sk_server_address_ = sk_server_address;
    return this;
  }
  const SensESPApp* set_sk_server_port(uint16_t sk_server_port) {
    this->sk_server_port_ = sk_server_port;
    return this;
  }
  const SensESPApp* set_system_status_led(
      std::shared_ptr<SystemStatusLed>& system_status_led) {
    this->system_status_led_ = system_status_led;
    return this;
  }
  const SensESPApp* set_admin_user(const char* username, const char* password) {
    pending_admin_user_ = username;
    pending_admin_pass_ = password;
    return this;
  }
  const SensESPApp* enable_ota(const char* password) {
    ota_password_ = password;
    return this;
  }
  const SensESPApp* set_button_pin(int pin) {
    button_gpio_pin_ = pin;
    return this;
  }
 
  void setup() {
    // call the parent setup()
    SensESPBaseApp::setup();
 
    // Install the log capture hook as early as practical so the web Log page
    // can show startup logging. UART output is preserved via the chained
    // handler. (Pre-WiFi early-boot and ISR-path output bypass the hook.)
    log_buffer_.install();
 
    ap_ssid_ = SensESPBaseApp::get_hostname();
 
    // Create the unified NetworkStateProducer FIRST so it is subscribed
    // to Network.onEvent before any provisioner brings its interface up
    // — that way we cannot miss the GOT_IP that fires when DHCP
    // completes a few hundred ms later.
    network_state_producer_ = std::make_shared<NetworkStateProducer>();
 
    // Create the chosen provisioner. If the builder installed a custom
    // factory (via set_network_provisioner_factory()), use it; otherwise
    // default to WiFi using the legacy constructor arguments — this
    // preserves backward compatibility for every existing user app that
    // calls set_wifi_client() or just relies on the defaults.
    if (provisioner_factory_) {
      network_provisioner_ = provisioner_factory_();
      if (!network_provisioner_) {
        ESP_LOGE(
            __FILENAME__,
            "provisioner_factory_ returned nullptr; falling back to "
            "WiFiProvisioner so the rest of setup() has a valid object.");
      }
    }
    if (!network_provisioner_) {
      std::shared_ptr<WiFiProvisioner> wifi;
      if (!wifi_client_configs_.empty()) {
        // Multi-network client list provided in code (set_wifi_clients()).
        wifi = std::make_shared<WiFiProvisioner>("/System/WiFi Settings",
                                                 wifi_client_configs_, ap_ssid_,
                                                 ap_password_);
      } else {
        // Legacy single-SSID path (set_wifi_client() or defaults).
        wifi = std::make_shared<WiFiProvisioner>("/System/WiFi Settings", ssid_,
                                                 wifi_client_password_,
                                                 ap_ssid_, ap_password_);
      }
      network_provisioner_ = wifi;
      wifi_provisioner_ = wifi;
    }
 
    // Register the WiFi-specific provisioner as a ConfigItem so the
    // existing /System/WiFi Settings web UI continues to work. Other
    // provisioners are responsible for registering their own ConfigItems
    // from inside their own constructors.
    if (wifi_provisioner_) {
      ConfigItem(wifi_provisioner_);
    }
 
    // Backward compat: the old Networking class was a
    // ValueProducer<WiFiState>. Forward state from the unified
    // NetworkStateProducer so code that did networking->connect_to(...)
    // continues to work.
    if (wifi_provisioner_ && network_state_producer_) {
      auto nsp = network_state_producer_;
      auto wp = wifi_provisioner_;
      nsp->attach([nsp, wp]() { wp->emit(nsp->get()); });
    }
 
    if (ota_password_ != nullptr) {
      // create the OTA object
      ota_ = std::make_shared<OTA>(ota_password_);
    }
 
    // Captive portal is meaningful only on WiFi (where there's a soft-AP).
    bool captive_portal_enabled = false;
    IPAddress captive_portal_ap_ip;
    if (wifi_provisioner_) {
      captive_portal_enabled = wifi_provisioner_->is_captive_portal_enabled();
      captive_portal_ap_ip = wifi_provisioner_->soft_ap_ip();
    }
 
    // create the HTTP server
    this->http_server_ = std::make_shared<HTTPServer>();
    this->http_server_->set_captive_portal(captive_portal_enabled,
                                           captive_portal_ap_ip);
 
    if (pending_admin_user_.length() > 0) {
      http_server_->set_auth_credentials(
          pending_admin_user_.c_str(), pending_admin_pass_.c_str(), true);
    }
 
    // Add the default HTTP server response handlers
    add_static_file_handlers(this->http_server_);
    add_base_app_http_command_handlers(this->http_server_);
    // WiFi-specific REST handlers (/api/wifi/scan etc.) only register
    // when the active provisioner is WiFi.
    if (wifi_provisioner_) {
      add_app_http_command_handlers(this->http_server_, wifi_provisioner_);
    } else {
      // Always register the transport-agnostic subset (TOFU reset).
      add_tofu_reset_handler(this->http_server_);
    }
    add_config_handlers(this->http_server_);
    add_button_handlers(this->http_server_);
 
    ConfigItem(this->http_server_);
 
    // create the SK delta queue
    sk_delta_queue_ = std::make_shared<SKDeltaQueue>();
 
    // create the websocket client
    bool const use_mdns = sk_server_address_ == "";
    this->ws_client_ = std::make_shared<SKWSClient>(
        "/System/Signal K Settings", sk_delta_queue_, sk_server_address_,
        sk_server_port_, use_mdns);
 
    ConfigItem(this->ws_client_);
 
    // Connect the system status controller. The unified
    // NetworkStateProducer feeds it state from any active interface.
    // (The consumer is still named get_wifi_state_consumer() for now —
    // it accepts NetworkState because LinkState=WiFiState=NetworkState
    // are aliases. Renaming the consumer is a separate cleanup.)
    this->network_state_producer_->connect_to(
        &system_status_controller_->get_wifi_state_consumer());
    this->ws_client_->connect_to(
        &system_status_controller_->get_ws_connection_state_consumer());
 
    // create the MDNS discovery object
    mdns_discovery_ = std::make_shared<MDNSDiscovery>();
 
    // create a system status led and connect it
 
    if (system_status_led_ == nullptr) {
#ifdef PIN_RGB_LED
      system_status_led_ = std::make_shared<RGBSystemStatusLed>(PIN_RGB_LED);
#elif defined(LED_BUILTIN)
      system_status_led_ = std::make_shared<SystemStatusLed>(LED_BUILTIN);
#endif
    }
    if (system_status_led_ != nullptr) {
      this->system_status_controller_->connect_to(
          system_status_led_->system_status_consumer_);
      this->ws_client_->get_delta_tx_count_producer().connect_to(
          system_status_led_->get_delta_tx_count_consumer());
    }
 
    // create the button handler
    if (button_gpio_pin_ != -1) {
      button_handler_ = std::make_shared<ButtonHandler>(button_gpio_pin_);
    }
 
    // connect status page items
    connect_status_page_items();
  }
 
  // Collect metrics for the status page
  void connect_status_page_items() {
    // Reset cause and the previous boot's heap watermark are fixed for this
    // session; capture them once here.
    begin_reset_info();
    reset_reason_ui_output_.set(String(reset_reason_str()));
    min_free_before_reset_ui_output_.set(
        static_cast<int>(min_free_heap_before_reset()));
 
    this->hostname_->connect_to(&this->hostname_ui_output_);
    this->event_loop_->onRepeat(4999, [this]() {
      // WiFi-specific status: only populated when WiFi is the active
      // provisioner. On Ethernet (or other transports), the SSID slot
      // is left empty and RSSI reads as 0.
      if (wifi_provisioner_) {
        wifi_ssid_ui_output_.set(wifi_provisioner_->ssid());
        wifi_rssi_ui_output_.set(wifi_provisioner_->rssi());
      } else {
        wifi_ssid_ui_output_.set(String(""));
        wifi_rssi_ui_output_.set(0);
      }
      mac_address_ui_output_.set(network_provisioner_->mac_address());
      free_memory_ui_output_.set(ESP.getFreeHeap());
      min_free_memory_ui_output_.set(ESP.getMinFreeHeap());
      // Carry this boot's heap low-water mark into RTC memory so it survives a
      // crash and reports as "min free before last reset" on the next boot.
      update_min_free_heap_watermark();
 
      // Uptime
      uptime_ui_output_.set(millis() / 1000);
 
      // Event loop queue sizes
      int event_loop_queue_size = event_loop_->getEventQueueSize();
      int event_loop_timed_queue_size = event_loop_->getTimedEventQueueSize();
      int event_loop_untimed_queue_size =
          event_loop_->getUntimedEventQueueSize();
 
      // Total tick count
      uint64_t current_tick_count = event_loop_->getTickCount();
      total_tick_count_ui_output_.set(current_tick_count);
 
      // Event counts
      uint64_t current_event_count = event_loop_->getEventCount();
      uint64_t current_timed_event_count = event_loop_->getTimedEventCount();
      uint64_t current_untimed_event_count =
          event_loop_->getUntimedEventCount();
      event_count_ui_output_.set(current_event_count);
      timed_event_count_ui_output_.set(current_timed_event_count);
      untimed_event_count_ui_output_.set(current_untimed_event_count);
 
      // Ticks and events per second during last interval
      static uint64_t last_tick_count = 0;
      static uint64_t last_event_count = 0;
      static uint64_t last_timed_event_count = 0;
      static uint64_t last_untimed_event_count = 0;
      static uint64_t last_millis = 0;
      uint64_t current_millis = millis();
      float interval_seconds = (current_millis - last_millis) / 1000.0;
 
      uint64_t ticks_diff = current_tick_count - last_tick_count;
      uint64_t events_diff = current_event_count - last_event_count;
      uint64_t timed_events_diff =
          current_timed_event_count - last_timed_event_count;
      uint64_t untimed_events_diff =
          current_untimed_event_count - last_untimed_event_count;
 
      // Set outputs
      event_loop_queue_size_ui_output_.set(event_loop_queue_size);
      event_loop_timed_queue_ui_output_.set(event_loop_timed_queue_size);
      event_loop_untimed_queue_ui_output_.set(event_loop_untimed_queue_size);
      event_loop_interrupt_queue_ui_output_.set(
          event_loop_->getISREventQueueSize());
 
      ticks_per_second_ui_output_.set(int(ticks_diff / interval_seconds));
      events_per_second_ui_output_.set(int(events_diff / interval_seconds));
      timed_events_per_second_ui_output_.set(
          int(timed_events_diff / interval_seconds));
      untimed_events_per_second_ui_output_.set(
          int(untimed_events_diff / interval_seconds));
 
      // Update last values
      last_tick_count = current_tick_count;
      last_event_count = current_event_count;
      last_timed_event_count = current_timed_event_count;
      last_untimed_event_count = current_untimed_event_count;
      last_millis = current_millis;
 
      sk_server_address_ui_output_.set(ws_client_->get_server_address());
      sk_server_port_ui_output_.set(ws_client_->get_server_port());
      sk_server_connection_ui_output_.set(ws_client_->get_connection_status());
    });
    ws_client_->get_delta_tx_count_producer().connect_to(
        &delta_tx_count_ui_output_);
    ws_client_->get_delta_rx_count_producer().connect_to(
        &delta_rx_count_ui_output_);
  }
 
  String ssid_ = "";
  String wifi_client_password_ = "";
  // Optional multi-network client list. When non-empty, setup() constructs
  // the default WiFiProvisioner from this list (failing over between the
  // entries) instead of the single ssid_/wifi_client_password_ pair.
  std::vector<ClientSSIDConfig> wifi_client_configs_;
  String sk_server_address_ = "";
  uint16_t sk_server_port_ = 0;
  String ap_ssid_ = "";
  String ap_password_ = "thisisfine";
  const char* ota_password_ = nullptr;
  String pending_admin_user_;
  String pending_admin_pass_;
 
  std::shared_ptr<MDNSDiscovery> mdns_discovery_;
  std::shared_ptr<HTTPServer> http_server_;
 
  LogBuffer log_buffer_;
 
  std::shared_ptr<BaseSystemStatusLed> system_status_led_;
  std::shared_ptr<SystemStatusController> system_status_controller_ =
      std::make_shared<SystemStatusController>();
  int button_gpio_pin_ = BUTTON_BUILTIN;
  std::shared_ptr<ButtonHandler> button_handler_;
 
  std::shared_ptr<NetworkStateProducer> network_state_producer_;
  std::shared_ptr<NetworkProvisioner> network_provisioner_;
  std::shared_ptr<WiFiProvisioner> wifi_provisioner_;
  std::function<std::shared_ptr<NetworkProvisioner>()> provisioner_factory_;
 
  std::shared_ptr<OTA> ota_;
  std::shared_ptr<SKDeltaQueue> sk_delta_queue_;
  std::shared_ptr<SKWSClient> ws_client_;
 
  StatusPageItem<int> free_memory_ui_output_{"Free memory (bytes)", 0, "System",
                                             1000};
  StatusPageItem<int> uptime_ui_output_{"Uptime (s)", 0, "System", 1100};
 
  StatusPageItem<int> min_free_memory_ui_output_{"Min free memory (bytes)", 0,
                                                 "System", 1010};
  StatusPageItem<int> min_free_before_reset_ui_output_{
      "Min free memory before last reset (bytes)", 0, "System", 1020};
  StatusPageItem<String> reset_reason_ui_output_{"Last reset reason", "",
                                                 "System", 1030};
 
  StatusPageItem<String> hostname_ui_output_{"Hostname", "", "Network", 1200};
  StatusPageItem<String> mac_address_ui_output_{"MAC Address", "", "Network",
                                                 1300};
  StatusPageItem<String> wifi_ssid_ui_output_{"SSID", "", "Network", 1400};
 
  StatusPageItem<int8_t> wifi_rssi_ui_output_{"WiFi signal strength (dB)", -128,
                                              "Network", 1500};
 
  StatusPageItem<String> sk_server_address_ui_output_{"Signal K server address",
                                                      "", "Signal K", 1600};
  StatusPageItem<uint16_t> sk_server_port_ui_output_{"Signal K server port", 0,
                                                     "Signal K", 1700};
  StatusPageItem<String> sk_server_connection_ui_output_{"SK connection status",
                                                         "", "Signal K", 1800};
  StatusPageItem<int> delta_tx_count_ui_output_{"SK Delta TX count", 0,
                                                "Signal K", 1900};
  StatusPageItem<int> delta_rx_count_ui_output_{"SK Delta RX count", 0,
                                                "Signal K", 2000};
 
  StatusPageItem<int> event_loop_queue_size_ui_output_{
      "Event Loop queue size", 0, "Event Loop Queues", 2100};
  StatusPageItem<int> event_loop_timed_queue_ui_output_{
      "Event Loop timed queue size", 0, "Event Loop Queues", 2200};
  StatusPageItem<int> event_loop_untimed_queue_ui_output_{
      "Event Loop untimed queue size", 0, "Event Loop Queues", 2300};
  StatusPageItem<int> event_loop_interrupt_queue_ui_output_{
      "Event Loop interrupt queue size", 0, "Event Loop Queues", 2400};
 
  StatusPageItem<uint64_t> total_tick_count_ui_output_{
      "Total ticks processed", 0, "Event Loop Lifetime", 2500};
  StatusPageItem<uint64_t> event_count_ui_output_{"Events processed", 0,
                                                  "Event Loop Lifetime", 2600};
  StatusPageItem<uint64_t> timed_event_count_ui_output_{
      "Timed events processed", 0, "Event Loop Lifetime", 2700};
  StatusPageItem<uint64_t> untimed_event_count_ui_output_{
      "Untimed events processed", 0, "Event Loop Lifetime", 2800};
  StatusPageItem<float> ticks_per_second_ui_output_{
      "Ticks per second", 0, "Event Loop Performance", 2900};
  StatusPageItem<float> events_per_second_ui_output_{
      "Events per second", 0, "Event Loop Performance", 3000};
  StatusPageItem<float> timed_events_per_second_ui_output_{
      "Timed events per second", 0, "Event Loop Performance", 3100};
  StatusPageItem<float> untimed_events_per_second_ui_output_{
      "Untimed events per second", 0, "Event Loop Performance", 3200};
 
  StatusPageItem<String> sensesp_version_ui_output_{
      "SenseESP version", kSensESPVersion, "Software", 3300};
  StatusPageItem<String> build_info_ui_output_{
      "Build date", __DATE__ " " __TIME__, "Software", 3400};
 
  // Placeholders for system status sensors in case they are created
  std::shared_ptr<ValueProducer<float>> system_hz_sensor_;
  std::shared_ptr<ValueProducer<uint32_t>> free_mem_sensor_;
  std::shared_ptr<ValueProducer<float>> uptime_sensor_;
  std::shared_ptr<ValueProducer<String>> ip_address_sensor_;
  std::shared_ptr<ValueProducer<int>> wifi_signal_sensor_;
 
  friend class WebServer;
  friend class SensESPAppBuilder;
};
 
}  // namespace sensesp
 
#endif