Deamon management

daemon/main.cpp

@@ -0,0 +1,118 @@
+// gKeyMapper daemon - remaps G1..G9 on the Logitech G910.
+//
+// It reads the raw HID reports of the keyboard's vendor interface, looks up the
+// configured action and replays it ("key" via uinput, "command" via exec).
+//
+// Milestones: M0 (shared core), M1 (device bring-up/decoding), M2 (action
+// execution) and M3 (config watching + lifecycle) are done; the GUI channel
+// (D-Bus) is still open (M4).
+
+#include <csignal>
+#include <cstdint>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+#include "action.h"
+#include "config_watch.h"
+#include "device_tables.h"
+#include "g910_device.h"
+#include "mapping.h"
+
+namespace {
+
+volatile std::sig_atomic_t g_running = 1;
+volatile std::sig_atomic_t g_reload = 0;
+
+void handle_stop(int /*signum*/) {
+    g_running = 0;
+}
+
+void handle_reload(int /*signum*/) {
+    g_reload = 1;
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+    std::signal(SIGINT, handle_stop);
+    std::signal(SIGTERM, handle_stop);
+    std::signal(SIGHUP, handle_reload);
+    std::signal(SIGUSR1, handle_reload);
+    std::signal(SIGCHLD, SIG_IGN); // auto-reap launched commands
+
+    std::string configPath = gkeymapper::default_config_path();
+    if (argc > 1) {
+        configPath = argv[1];
+    }
+
+    gkeymapper::MappingSet mappings = gkeymapper::parse_mappings("");
+
+    // Reads the config; on failure the previous mappings stay in place, so a
+    // transient read error never silently disables every key.
+    auto reload = [&]() {
+        if (gkeymapper::load_mappings_file(configPath, mappings)) {
+            std::fprintf(stderr, "gkeymapper-daemon: loaded %s\n", configPath.c_str());
+        } else {
+            std::fprintf(stderr, "gkeymapper-daemon: cannot read %s\n", configPath.c_str());
+        }
+    };
+    reload();
+
+    // The GUI is the writer; a save is picked up through inotify, SIGHUP/SIGUSR1
+    // stay as the fallback for scripts and for systems without inotify.
+    gkeymapper::daemon::ConfigWatcher watcher;
+    watcher.init(configPath);
+
+    gkeymapper::daemon::ActionRunner actions;
+    actions.init();
+
+    gkeymapper::daemon::GKeyDevice device;
+    if (!device.open()) {
+        return 1;
+    }
+    device.disable_binding();
+    const gkeymapper::daemon::DeviceProfile* profile = device.profile();
+
+    uint8_t buffer[64];
+    while (g_running) {
+        // The loop wakes up at least every read timeout, which also bounds how
+        // long a config change takes to be applied (well under a second).
+        watcher.poll_events();
+        if (g_reload || watcher.take_change()) {
+            g_reload = 0;
+            reload();
+        }
+
+        int n = device.read_report(buffer, sizeof(buffer), 500);
+        if (n == 0) {
+            continue; // no report within the timeout
+        }
+        if (n < 0) {
+            std::fprintf(stderr, "gkeymapper-daemon: read error (%d), reopening\n", n);
+            device.close();
+            if (!device.open()) {
+                return 1;
+            }
+            device.disable_binding();
+            profile = device.profile();
+            continue;
+        }
+
+        int index = gkeymapper::daemon::match_gkey(*profile, buffer, n);
+        if (index >= 0 && index < static_cast<int>(mappings.keys.size())) {
+            const gkeymapper::Mapping& mapping = mappings.keys[index];
+            std::printf("G%d -> %s:%s\n", index + 1,
+                        gkeymapper::action_type_token(mapping.type),
+                        mapping.target.c_str());
+            std::fflush(stdout);
+            actions.run(mapping);
+        } else if (gkeymapper::daemon::is_release_report(*profile, buffer, n)) {
+            // Key released; nothing to do.
+        }
+        // Media keys and LED acknowledgements are ignored.
+    }
+
+    device.close();
+    return 0;
+}