yaft: Watch for config changes

Author: timower

apps/yaft/YaftWidget.cpp

@@ -10,7 +10,9 @@
 
 #include <Device.h>
 
-#include <sstream>
+#include <sys/inotify.h>
+
+#include <unistdpp/file.h>
 
 using namespace rmlib;
 
@@ -69,6 +71,15 @@ forkAndExec(int* master,
 }
 } // namespace
 
+YaftConfigAndError
+Yaft::getConfigAndError() const {
+  if (std::holds_alternative<YaftConfigAndError>(configOrPath)) {
+    return std::get<YaftConfigAndError>(configOrPath);
+  }
+
+  return loadConfigOrMakeDefault(std::get<std::filesystem::path>(configOrPath));
+}
+
 YaftState::~YaftState() {
   if (term) {
     term_die(term.get());
@@ -87,15 +98,30 @@ YaftState::init(rmlib::AppContext& ctx, const rmlib::BuildContext& /*unused*/) {
   // term_init needs the maximum size of the terminal.
   int maxSize = std::max(ctx.getFbCanvas().width(), ctx.getFbCanvas().height());
   if (!term_init(term.get(), maxSize, maxSize)) {
-    std::cout << "Error init term\n";
+    std::cerr << "Error init term\n";
     ctx.stop();
     return;
   }
 
-  if (const auto& err = getWidget().configError; err.has_value()) {
+  auto cfgAndError = getWidget().getConfigAndError();
+  config = std::move(cfgAndError.config);
+
+  if (const auto& err = cfgAndError.err; err.has_value()) {
     logTerm(err->msg);
   }
 
+  if (std::holds_alternative<std::filesystem::path>(getWidget().configOrPath)) {
+    watchPath = std::get<std::filesystem::path>(getWidget().configOrPath);
+    inotifyFd = unistdpp::FD(inotify_init());
+    if (inotifyFd.isValid()) {
+      inotifyWd = inotify_add_watch(inotifyFd.fd,
+                                    watchPath.parent_path().c_str(),
+                                    IN_MODIFY | IN_CREATE | IN_CLOSE_WRITE);
+
+      ctx.listenFd(inotifyFd.fd, [this, &ctx] { readInotify(ctx); });
+    }
+  }
+
   initSignalHandler(ctx);
 
   if (!forkAndExec(&term->fd,
@@ -139,8 +165,6 @@ YaftState::init(rmlib::AppContext& ctx, const rmlib::BuildContext& /*unused*/) {
 
 void
 YaftState::checkLandscape(rmlib::AppContext& ctx) {
-  const auto& config = getWidget().config;
-
   if (config.autoRotate) {
     const auto hasKeyboard =
       ctx.getInputManager().getBaseDevices().pogoKeyboard != nullptr;
@@ -151,6 +175,46 @@ YaftState::checkLandscape(rmlib::AppContext& ctx) {
   }
 }
 
+void
+YaftState::readInotify(rmlib::AppContext& ctx) const {
+  union {
+    std::array<char, 4096> buf;
+    inotify_event ev;
+  } evUnion;
+
+  auto read = unistdpp::read(inotifyFd, &evUnion, sizeof(evUnion));
+  if (!read.has_value()) {
+    std::cerr << "inotify read failed: " << to_string(read.error()) << "\n";
+    return;
+  }
+
+  bool shouldReload = false;
+  const inotify_event* event;
+  for (char* ptr = evUnion.buf.begin(); ptr < evUnion.buf.begin() + *read;
+       ptr += sizeof(struct inotify_event) + event->len) {
+    event = (const struct inotify_event*)ptr;
+
+    if (event->wd == inotifyWd && event->name == watchPath.filename()) {
+      shouldReload = true;
+    }
+  }
+
+  if (!shouldReload) {
+    return;
+  }
+
+  std::cerr << "inotify: Config updated, reloading\n";
+  setState([&](auto& self) {
+    auto cfgAndErr = loadConfig(self.watchPath);
+    if (cfgAndErr.err.has_value()) {
+      self.logTerm(cfgAndErr.err->msg);
+    }
+
+    self.config = cfgAndErr.config;
+    self.checkLandscape(ctx);
+  });
+}
+
 YaftState
 Yaft::createState() {
   return {};

apps/yaft/YaftWidget.h

@@ -10,23 +10,26 @@
 #include <UI/Rotate.h>
 #include <UI/StatefulWidget.h>
 
+#include <filesystem>
+
 class YaftState;
 
 class Yaft : public rmlib::StatefulWidget<Yaft> {
 public:
   Yaft(const char* cmd, char* const argv[], YaftConfigAndError config)
-    : config(std::move(config.config))
-    , configError(std::move(config.err))
-    , cmd(cmd)
-    , argv(argv) {}
+    : configOrPath(std::move(config)), cmd(cmd), argv(argv) {}
+
+  Yaft(const char* cmd, char* const argv[], std::filesystem::path configPath)
+    : configOrPath(std::move(configPath)), cmd(cmd), argv(argv) {}
 
   static YaftState createState();
 
+  YaftConfigAndError getConfigAndError() const;
+
 private:
   friend class YaftState;
 
-  YaftConfig config;
-  std::optional<YaftConfigError> configError;
+  std::variant<YaftConfigAndError, std::filesystem::path> configOrPath;
 
   const char* cmd;
   char* const* argv;
@@ -41,15 +44,11 @@ class YaftState : public rmlib::StateBase<Yaft> {
 
   void init(rmlib::AppContext& ctx, const rmlib::BuildContext& /*unused*/);
 
-  void checkLandscape(rmlib::AppContext& ctx);
-
   auto build(rmlib::AppContext& ctx,
              const rmlib::BuildContext& buildCtx) const {
     using namespace rmlib;
 
-    const auto& cfg = getWidget().config;
-
-    const auto& layout = [this, &cfg]() -> const Layout& {
+    const auto& layout = [this]() -> const Layout& {
       if (hideKeyboard) {
         return empty_layout;
       }
@@ -58,31 +57,41 @@ class YaftState : public rmlib::StateBase<Yaft> {
         return hidden_layout;
       }
 
-      return *cfg.layout;
+      return *config.layout;
     }();
 
-    const auto repeatRateMs = std::chrono::milliseconds(1000) / cfg.repeatRate;
-    return Rotated(rotation,
-                   Column(Expanded(Screen(term.get(), false, cfg.autoRefresh)),
-                          Keyboard(term.get(),
-                                   KeyboardParams{
-                                     .layout = layout,
-                                     .keymap = *cfg.keymap,
-                                     .repeatDelay = std::chrono::milliseconds(
-                                       cfg.repeatDelay),
-                                     .repeatTime = repeatRateMs,
-                                   },
-                                   [this](int num) {
-                                     setState([](auto& self) {
-                                       self.smallKeyboard = !self.smallKeyboard;
-                                     });
-                                   })));
+    const auto repeatRateMs =
+      std::chrono::milliseconds(1000) / config.repeatRate;
+    return Rotated(
+      rotation,
+      Column(
+        Expanded(Screen(term.get(), false, config.autoRefresh)),
+        Keyboard(term.get(),
+                 KeyboardParams{
+                   .layout = layout,
+                   .keymap = *config.keymap,
+                   .repeatDelay = std::chrono::milliseconds(config.repeatDelay),
+                   .repeatTime = repeatRateMs,
+                 },
+                 [this](int num) {
+                   setState([](auto& self) {
+                     self.smallKeyboard = !self.smallKeyboard;
+                   });
+                 })));
   }
 
 private:
+  void checkLandscape(rmlib::AppContext& ctx);
+  void readInotify(rmlib::AppContext& ctx) const;
+
   std::unique_ptr<terminal_t> term;
   rmlib::TimerHandle pogoTimer;
 
+  std::filesystem::path watchPath;
+  unistdpp::FD inotifyFd;
+  int inotifyWd;
+
+  YaftConfig config;
   rmlib::Rotation rotation = rmlib::Rotation::None;
   bool smallKeyboard = false;
   bool hideKeyboard = false;

apps/yaft/config.cpp

@@ -13,10 +13,11 @@ layout = "qwerty"
 # Keymap for any physical keyboards. Defaults to the us rM pogo keyboard.
 keymap = "rm-qwerty"
 
-# Orientation of yaft:
-# Auto rotate if keyboard is connected
+# Auto rotate if keyboard is connected.
 auto-rotate = true
-# Orientation if no keyboard is connected
+
+# Orientation if no keyboard is connected:
+#  * none, clockwise, inverted, counterclockwise
 rotation = "none"
 
 # Do a full refresh after 1024 updates.
@@ -29,25 +30,6 @@ repeat-delay = 600
 repeat-rate = 25
 )";
 
-std::filesystem::path
-getConfigPath() {
-  const auto configDir = [] {
-    if (const auto* xdgCfg = getenv("XDG_CONFIG_HOME");
-        xdgCfg != nullptr && xdgCfg[0] != 0) {
-      return std::filesystem::path(xdgCfg);
-    }
-
-    const auto* home = getenv("HOME");
-    if (home == nullptr || home[0] == 0) {
-      home = "/home/root";
-    }
-
-    return std::filesystem::path(home) / ".config" / "yaft";
-  }();
-
-  return configDir / "config.toml";
-}
-
 void
 addError(std::optional<YaftConfigError>& error, YaftConfigError err) {
   if (!error.has_value()) {
@@ -135,24 +117,42 @@ getConfig(const toml::table& input) {
 
 } // namespace
 
+std::filesystem::path
+getConfigPath() {
+  const auto configDir = [] {
+    if (const auto* xdgCfg = getenv("XDG_CONFIG_HOME");
+        xdgCfg != nullptr && xdgCfg[0] != 0) {
+      return std::filesystem::path(xdgCfg);
+    }
+
+    const auto* home = getenv("HOME");
+    if (home == nullptr || home[0] == 0) {
+      home = "/home/root";
+    }
+
+    return std::filesystem::path(home) / ".config" / "yaft";
+  }();
+
+  return configDir / "config.toml";
+}
+
 YaftConfig
 YaftConfig::getDefault() {
   auto tbl = toml::parse(default_config);
   return getConfig(tbl).config;
 }
 
 YaftConfigAndError
-loadConfig() {
+loadConfig(const std::filesystem::path& path) {
   toml::table tbl;
 
-  const auto path = getConfigPath();
   if (!std::filesystem::exists(path)) {
     return { YaftConfig::getDefault(),
              YaftConfigError{ YaftConfigError::Missing, path.string() } };
   }
 
   try {
-    tbl = toml::parse_file(getConfigPath().c_str());
+    tbl = toml::parse_file(path.c_str());
   } catch (const toml::parse_error& err) {
     return { YaftConfig::getDefault(),
              YaftConfigError{ YaftConfigError::Syntax,
@@ -164,8 +164,7 @@ loadConfig() {
 }
 
 OptError<>
-saveDefaultConfig() {
-  const auto path = getConfigPath();
+saveDefaultConfig(const std::filesystem::path& path) {
   const auto dir = path.parent_path();
 
   std::error_code ec;
@@ -189,16 +188,16 @@ saveDefaultConfig() {
 }
 
 YaftConfigAndError
-loadConfigOrMakeDefault() {
-  auto result = loadConfig();
+loadConfigOrMakeDefault(const std::filesystem::path& path) {
+  auto result = loadConfig(path);
   if (!result.err.has_value()) {
     return result;
   }
 
   auto& err = *result.err;
   if (err.type == YaftConfigError::Missing) {
     err.msg = "No config, creating new one\r\n";
-    if (const auto optErr = saveDefaultConfig(); !optErr.has_value()) {
+    if (const auto optErr = saveDefaultConfig(path); !optErr.has_value()) {
       err.msg += optErr.error().msg + "\r\n";
     }
   } else {

apps/yaft/config.h

@@ -2,6 +2,7 @@
 
 #include "Error.h"
 
+#include <filesystem>
 #include <optional>
 #include <string>
 
@@ -43,16 +44,19 @@ struct YaftConfigAndError {
   std::optional<YaftConfigError> err;
 };
 
+std::filesystem::path
+getConfigPath();
+
 /// Load the config from the `~/.config/yaft/config.toml` location.
 YaftConfigAndError
-loadConfig();
+loadConfig(const std::filesystem::path& path);
 
 OptError<>
-saveDefaultConfig();
+saveDefaultConfig(const std::filesystem::path& path);
 
 /// Always returns a config, either the default one or the one on the file
 /// system. Will also make a new config file if it didn't exist.
 ///
 /// If any error occured during the loading of the config, it's also returned.
 YaftConfigAndError
-loadConfigOrMakeDefault();
+loadConfigOrMakeDefault(const std::filesystem::path& path);

apps/yaft/main.cpp

@@ -36,9 +36,7 @@ main(int argc, char* argv[]) {
     args = const_cast<char* const*>(shellArgs);
   }
 
-  auto cfg = loadConfigOrMakeDefault();
-
-  unistdpp::fatalOnError(runApp(Yaft(cmd, args, std::move(cfg))));
+  unistdpp::fatalOnError(runApp(Yaft(cmd, args, getConfigPath())));
 
   return 0;
 }

flake.nix

@@ -71,6 +71,7 @@
             packages = with pkgs; [
               clang-tools
               libllvm
+              lldb
             ];
           };
         }