Implement input device discovery

Instead of using hardcoded paths to input devices, VNSee now enumerates
all available input devices and opens the ones that match expected
criteria. This makes it robust to device path changes, such as the one
that happened on rM1 version 2.9.

Author: matteodelabre

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.7)
-project(VNSee VERSION 0.3.1)
+project(VNSee VERSION 0.4.1)
 
 find_package(PkgConfig REQUIRED)
 pkg_check_modules(LibVNCClient libvncclient)
@@ -57,6 +57,7 @@ add_executable(vnsee
     src/main.cpp
     src/rmioc/buttons.cpp
     src/rmioc/device.cpp
+    src/rmioc/file.cpp
     src/rmioc/input.cpp
     src/rmioc/mxcfb.cpp
     src/rmioc/pen.cpp

src/app/client.cpp

@@ -125,10 +125,11 @@ client::~client()
     rfbClientCleanup(this->vnc_client);
 }
 
+// NOLINTNEXTLINE(readability-function-cognitive-complexity)
 auto client::event_loop() -> bool
 {
     // Maximum time to wait before timeout in the next poll
-    int timeout = -1;
+    long timeout = -1;
 
     // Flag used for quitting the event loop
     bool quit = false;
@@ -158,7 +159,7 @@ auto client::event_loop() -> bool
         while (poll(
                     this->polled_fds.data(),
                     this->polled_fds.size(),
-                    timeout) == -1)
+                    static_cast<int>(timeout)) == -1)
         {
             if (errno != EAGAIN)
             {

src/app/event_loop.hpp

@@ -19,7 +19,7 @@ struct event_loop_status
      * The minimum timeout among all the event loop subroutines will be used.
      * Can be -1 if no more work is needed (wait indefinitely).
      */
-    int timeout;
+    long timeout;
 };
 
 /** List of mouse button flags used by the VNC protocol. */

src/app/screen.cpp

@@ -33,16 +33,17 @@ constexpr chrono::milliseconds fast_repaint_delay{50};
 namespace app
 {
 
+// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast,cppcoreguidelines-avoid-non-const-global-variables,cppcoreguidelines-avoid-magic-numbers)
+void* screen::instance_tag = reinterpret_cast<void*>(6803);
+
 screen::screen(rmioc::screen& device, rfbClient* vnc_client)
 : device(device)
 , vnc_client(vnc_client)
 , repaint_mode(repaint_modes::standard)
 {
     rfbClientSetClientData(
         this->vnc_client,
-        // ↓ Use of C library
-        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-        reinterpret_cast<void*>(screen::instance_tag),
+        screen::instance_tag,
         this
     );
 
@@ -117,7 +118,7 @@ auto screen::event_loop() -> event_loop_status
         );
 
         auto now = chrono::steady_clock::now();
-        int wait_time = chrono::duration_cast<chrono::milliseconds>(
+        long wait_time = chrono::duration_cast<chrono::milliseconds>(
             next_update_time - now
         ).count();
 
@@ -144,8 +145,7 @@ auto screen::create_framebuf(rfbClient* vnc_client) -> rfbBool
     auto* that = reinterpret_cast<screen*>(
         rfbClientGetClientData(
             vnc_client,
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            reinterpret_cast<void*>(screen::instance_tag)
+            screen::instance_tag
         ));
 
     int xres = static_cast<int>(that->device.get_xres());
@@ -179,8 +179,7 @@ void screen::recv_update(
     auto* that = reinterpret_cast<screen*>(
         rfbClientGetClientData(
             vnc_client,
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            reinterpret_cast<void*>(screen::instance_tag)
+            screen::instance_tag
         ));
 
     if (x < 0 || y < 0
@@ -226,8 +225,7 @@ void screen::commit_updates(rfbClient* vnc_client, int x, int y, int w, int h)
     auto* that = reinterpret_cast<screen*>(
         rfbClientGetClientData(
             vnc_client,
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-            reinterpret_cast<void*>(screen::instance_tag)
+            screen::instance_tag
         ));
 
     // Register the region as pending update, potentially extending

src/app/screen.hpp

@@ -132,7 +132,7 @@ class screen
     std::chrono::steady_clock::time_point last_repaint;
 
     /** Tag used for accessing the instance from C callbacks. */
-    static constexpr std::size_t instance_tag = 6803;
+    static void* instance_tag;
 
     /** Current repaint mode. */
     repaint_modes repaint_mode;

src/app/touch.cpp

@@ -54,7 +54,7 @@ auto touch::process_events(bool inhibit) -> event_loop_status
                 // Compute the mean touch position
                 int summed_x = 0;
                 int summed_y = 0;
-                int total_points = device_state.size();
+                int total_points = static_cast<int>(device_state.size());
 
                 for (const auto& [id, slot] : device_state)
                 {

src/main.cpp

@@ -46,6 +46,7 @@ constexpr int default_server_port = 5900;
 constexpr int min_port = 1;
 constexpr int max_port = (1U << 16U) - 1;
 
+// NOLINTNEXTLINE(readability-function-cognitive-complexity)
 auto main(int argc, const char* argv[]) -> int
 {
     // Read options from the command line

src/rmioc/buttons.cpp

@@ -1,5 +1,6 @@
 #include "buttons.hpp"
 #include <vector>
+#include <fcntl.h>
 #include <linux/input-event-codes.h>
 #include <linux/input.h>
 
@@ -10,6 +11,20 @@ buttons::buttons(const char* device_path)
 : input(device_path)
 {}
 
+auto buttons::is(const char* device_path) -> bool
+{
+    file_descriptor input_fd{device_path, O_RDONLY};
+    auto supp_events = supported_input_events(input_fd);
+
+    if (!supp_events.has_key())
+    {
+        return false;
+    }
+
+    auto supp_keys = supported_key_types(input_fd);
+    return supp_keys.has_power();
+}
+
 auto buttons::process_events() -> bool
 {
     auto events = this->fetch_events();

src/rmioc/buttons.hpp

@@ -19,6 +19,9 @@ class buttons : public input
      */
     buttons(const char* device_path);
 
+    /** Check if an input device is a buttons device. */
+    static bool is(const char* device_path);
+
     /**
      * Fetch new events from the buttons and process them.
      *

src/rmioc/device.cpp

@@ -1,11 +1,15 @@
 #include "device.hpp"
 #include "screen_mxcfb.hpp"
 #include "screen_rm2fb.hpp"
+#include <fcntl.h>
 #include <fstream>
+#include <filesystem>
 #include <stdexcept>
 #include <string>
 #include <utility>
 
+namespace fs = std::filesystem;
+
 namespace rmioc
 {
 
@@ -23,78 +27,94 @@ device::device(
 , screen_device(std::move(screen_device))
 {}
 
-auto device::detect(device_request request) -> device
+auto get_device_type() -> device::types
 {
     std::ifstream device_id_file{"/sys/devices/soc0/machine"};
     std::string device_id;
     std::getline(device_id_file, device_id);
 
-    types type = types::reMarkable1;
-    std::unique_ptr<buttons> buttons_device;
-    std::unique_ptr<touch> touch_device;
-    std::unique_ptr<pen> pen_device;
-    std::unique_ptr<screen> screen_device;
-
     if (device_id == "reMarkable 1.0" || device_id == "reMarkable Prototype 1")
     {
-        type = types::reMarkable1;
-
-        if (request.has_buttons())
-        {
-            buttons_device = std::make_unique<buttons>("/dev/input/event2");
-        }
+        return device::types::reMarkable1;
+    }
 
-        if (request.has_touch())
-        {
-            touch_device = std::make_unique<touch>(
-                "/dev/input/event1",
-                /* flip_x = */ true,
-                /* flip_y = */ true
-            );
-        }
+    if (device_id == "reMarkable 2.0")
+    {
+        return device::types::reMarkable2;
+    }
 
-        if (request.has_pen())
-        {
-            pen_device = std::make_unique<pen>(
-                "/dev/input/event0",
-                /* flip_x = */ false,
-                /* flip_y = */ true
-            );
-        }
+    throw std::runtime_error{"Unknown reMarkable model (device identifier \
+is “" + device_id + "”"};
+}
 
-        if (request.has_screen())
+void discover_input_devices(
+    const char* base_path,
+    device::types type,
+    device_request request,
+    std::unique_ptr<buttons>& buttons_device,
+    std::unique_ptr<touch>& touch_device,
+    std::unique_ptr<pen>& pen_device
+)
+{
+    for (const auto& entry : fs::directory_iterator(base_path))
+    {
+        if (entry.is_character_file())
         {
-            screen_device = std::make_unique<screen_mxcfb>("/dev/fb0");
+            const char* path = entry.path().c_str();
+
+            if (buttons::is(path))
+            {
+                if (request.has_buttons())
+                {
+                    buttons_device = std::make_unique<buttons>(path);
+                }
+            }
+            else if (touch::is(path))
+            {
+                if (request.has_touch())
+                {
+                    touch_device = std::make_unique<touch>(
+                        path,
+                        /* flip_x = */ type == device::types::reMarkable1,
+                        /* flip_y = */ true
+                    );
+                }
+            }
+            else if (pen::is(path))
+            {
+                if (request.has_pen())
+                {
+                    pen_device = std::make_unique<pen>(
+                        path,
+                        /* flip_x = */ false,
+                        /* flip_y = */ true
+                    );
+                }
+            }
         }
     }
-    else if (device_id == "reMarkable 2.0")
-    {
-        type = types::reMarkable2;
+}
 
-        if (request.has_buttons())
-        {
-            buttons_device = std::make_unique<buttons>("/dev/input/event0");
-        }
+auto device::detect(device_request request) -> device
+{
+    std::ifstream device_id_file{"/sys/devices/soc0/machine"};
+    std::string device_id;
+    std::getline(device_id_file, device_id);
 
-        if (request.has_touch())
-        {
-            touch_device = std::make_unique<touch>(
-                "/dev/input/event2",
-                /* flip_x = */ false,
-                /* flip_y = */ true
-            );
-        }
+    types type = get_device_type();
+    std::unique_ptr<buttons> buttons_device;
+    std::unique_ptr<touch> touch_device;
+    std::unique_ptr<pen> pen_device;
+    std::unique_ptr<screen> screen_device;
 
-        if (request.has_pen())
+    // Use the appropriate screen driver based on current device type
+    if (request.has_screen())
+    {
+        if (type == types::reMarkable1)
         {
-            pen_device = std::make_unique<pen>(
-                "/dev/input/event1",
-                /* flip_x = */ false,
-                /* flip_y = */ true
-            );
+            screen_device = std::make_unique<screen_mxcfb>("/dev/fb0");
         }
-
-        if (request.has_screen())
+        else
         {
             constexpr auto rm2fb_msgqueue_key = 0x2257c;
             screen_device = std::make_unique<screen_rm2fb>(
@@ -103,11 +123,12 @@ auto device::detect(device_request request) -> device
             );
         }
     }
-    else
-    {
-        throw std::runtime_error{"Unknown reMarkable model (device identifier \
-says “" + device_id + "”"};
-    }
+
+    // Auto-detect and open requested input devices
+    discover_input_devices(
+        "/dev/input", type, request,
+        buttons_device, touch_device, pen_device
+    );
 
     return device(
         type,