sensesp_base_app.h

Go to the documentation of this file.

#ifndef SENSESP_BASE_APP_H_
#define SENSESP_BASE_APP_H_
 
#ifndef BUTTON_BUILTIN
// Default button pin on ESP32-DevKitC devices is 0 (GPIO0),
// normally connected to the BOOT button.
#define BUTTON_BUILTIN 0
#endif
 
#include "sensesp.h"
 
#include <memory>
 
#include "esp_log.h"
#include "sensesp/system/filesystem.h"
#include "sensesp/system/observablevalue.h"
 
namespace sensesp {
 
constexpr auto kDefaultHostname = "SensESP";
 
inline void SetupLogging(esp_log_level_t default_level = ESP_LOG_DEBUG) {
  esp_log_level_set("*", default_level);
}
 
inline void SetupSerialDebug(uint32_t baudrate) {
  SetupLogging();
 
  if (baudrate != 115200) {
    ESP_LOGW(__FILENAME__, "SetupSerialDebug baudrate parameter is ignored.");
  }
}
 
// WARNING: This class uses a shared_ptr singleton pattern. Only one instance
// should exist at a time. Constructing multiple instances or calling get()
// before the builder sets up the instance will produce unexpected behavior.
// See GitHub issue #900 for planned improvements.
class SensESPBaseApp {
 protected:
  std::shared_ptr<reactesp::EventLoop> event_loop_;
 
 public:
  static const std::shared_ptr<SensESPBaseApp>& get() { return instance_; }
 
  static void clear_registries();
 
  virtual bool destroy() {
    bool outside_users = instance_.use_count() > 1;
 
    if (outside_users) {
      ESP_LOGW(__FILENAME__,
               "SensESPBaseApp instance has active references and won't be "
               "properly destroyed.");
    } else {
      // Only clear the registries when the app is actually being torn down.
      // If outside references survive, the registered objects survive too, and
      // clearing would strand live objects (they register only in their
      // constructors, so they would never re-appear).
      clear_registries();
    }
    instance_ = nullptr;
    return !outside_users;
  }
 
  virtual void start() {
    ESP_LOGW(__FILENAME__, "start() call is deprecated and can be removed.");
  }
 
  virtual void reset() {
    ESP_LOGW(__FILENAME__,
             "Resetting the device configuration to system defaults.");
    Resettable::reset_all();
 
    this->event_loop_->onDelay(1000, []() {
      ESP.restart();
      delay(1000);
    });
  }
 
  std::shared_ptr<ObservableValue<String>> get_hostname_observable() {
    return std::static_pointer_cast<ObservableValue<String>>(hostname_);
  }
 
  static String get_hostname() {
    return SensESPBaseApp::get()->get_hostname_observable().get()->get();
  }
 
  static std::shared_ptr<reactesp::EventLoop> get_event_loop() {
    return SensESPBaseApp::get()->event_loop_;
  }
 
 protected:
  SensESPBaseApp()
      : filesystem_{std::make_shared<Filesystem>()},
        event_loop_{std::make_shared<reactesp::EventLoop>()} {
    // Instance is now set by the builder
  }
 
  ~SensESPBaseApp() { instance_ = nullptr; }
 
  void init_hostname(const String& default_hostname = kDefaultHostname) {
    hostname_ = std::make_shared<PersistingObservableValue<String>>(
        default_hostname, "/system/hostname");
    ConfigItem(hostname_);
  }
 
  virtual void setup() {
    if (!hostname_) {
      init_hostname();
    }
  }
 
  static std::shared_ptr<SensESPBaseApp> instance_;
 
  void set_instance(const std::shared_ptr<SensESPBaseApp>& instance) {
    instance_ = instance;
  }
 
  std::shared_ptr<PersistingObservableValue<String>> hostname_;
 
  std::shared_ptr<Filesystem> filesystem_;
 
  const SensESPBaseApp* set_hostname(String hostname) {
    // Pass the builder's hostname as the default for the
    // PersistingObservableValue constructor. If a user has
    // configured a different hostname via the web UI, load()
    // in the constructor will override this default — no
    // special-case guard needed.
    if (!hostname_) {
      init_hostname(hostname);
    }
    return this;
  }
};
 
}  // namespace sensesp
 
#endif