ci: update Linux build image to Ubuntu 20.04

README.md

@@ -80,7 +80,7 @@ Windows 安装包会自动打包 `crossdesk_service.exe` 和 `crossdesk_session_
 
 依赖：
 - [xmake](https://xmake.io/#/guide/installation)
-- [cmake](https://cmake.org/download/) 3.21 及以上（系统版本过低时由 xmake 自动安装）
+- [cmake](https://cmake.org/download/) 3.21 及以上
 
 ### Linux
 
@@ -97,10 +97,11 @@ sudo apt-get install -y \
   libxtst-dev libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev \
   libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxcb-shm0-dev \
   libasound2-dev libsndio-dev libpulse-dev
-```
 
-Ubuntu 20.04 自带的 CMake 3.16 不满足要求时，xmake 会自动下载并使用
-CMake 3.21 或更高版本，无需手动替换系统 CMake。
+# Ubuntu 20.04 自带的 CMake 3.16 不满足 Slint 1.17 的要求
+python3 -m pip install --user cmake==3.31.6
+export PATH="$HOME/.local/bin:$PATH"
+```
 
 Ubuntu 20.04 默认的 GCC 9 缺少 Slint C++ API 所需的部分 C++20 标准库，
 因此上述命令同时安装并在后续配置中指定 GCC 10。
@@ -127,21 +128,17 @@ git submodule update --init --recursive
 # 已安装发行版 PipeWire 0.3 开发包时可跳过此步骤。
 sudo ./docker/linux-build/install-pipewire-sdk.sh
 
-xmake f -c -m release --USE_CUDA=false --toolchain=gcc-10 -y
+xmake f -m release --USE_CUDA=false --cc=gcc-10 --cxx=g++-10 -y
 xmake b -vy crossdesk
 ```
 
-这里应使用 `--toolchain=gcc-10`，以确保 CrossDesk 及 xmake 在配置阶段构建的
-libyuv 等第三方包都使用 GCC 10。只指定 `--cc`/`--cxx` 时，依赖安装可能仍回退到
-系统默认的 `/bin/cc` 和 `/bin/c++`。`-c` 会清除旧配置，切换编译器时必须保留。
-
 amd64 构建结果位于 `build/linux/x86_64/release/crossdesk`，arm64 构建结果位于 `build/linux/arm64/release/crossdesk`。
 
 启用 Wayland 和 DRM 的配置示例：
 
 ```bash
-xmake f -c -m release --USE_WAYLAND=true --USE_DRM=true --USE_CUDA=false \
-  --toolchain=gcc-10 -y
+xmake f -m release --USE_WAYLAND=true --USE_DRM=true --USE_CUDA=false \
+  --cc=gcc-10 --cxx=g++-10 -y
 xmake b -vy crossdesk
 ```
 

README_EN.md

@@ -85,7 +85,7 @@ If the remote Windows service is not installed, not running, or temporarily unav
 
 Requirements:
 - [xmake](https://xmake.io/#/guide/installation)
-- [cmake](https://cmake.org/download/) 3.21 or later (installed automatically by xmake when the system version is too old)
+- [cmake](https://cmake.org/download/) 3.21 or later
 
 ### Linux
 
@@ -103,11 +103,11 @@ sudo apt-get install -y \
   libxtst-dev libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev \
   libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxcb-shm0-dev \
   libasound2-dev libsndio-dev libpulse-dev
-```
 
-When Ubuntu 20.04's bundled CMake 3.16 is too old, xmake automatically
-downloads and uses CMake 3.21 or later; replacing the system CMake manually is
-not required.
+# Ubuntu 20.04's CMake 3.16 is too old for Slint 1.17.
+python3 -m pip install --user cmake==3.31.6
+export PATH="$HOME/.local/bin:$PATH"
+```
 
 Ubuntu 20.04's default GCC 9 lacks parts of the C++20 standard library needed
 by Slint's C++ API, so the commands above install GCC 10 and the configuration
@@ -136,23 +136,17 @@ git submodule update --init --recursive
 # PipeWire 0.3 development packages are already installed.
 sudo ./docker/linux-build/install-pipewire-sdk.sh
 
-xmake f -c -m release --USE_CUDA=false --toolchain=gcc-10 -y
+xmake f -m release --USE_CUDA=false --cc=gcc-10 --cxx=g++-10 -y
 xmake b -vy crossdesk
 ```
 
-Use `--toolchain=gcc-10` so that both CrossDesk and third-party packages such
-as libyuv, which xmake builds during configuration, use GCC 10. Specifying only
-`--cc`/`--cxx` may still let dependency builds fall back to the system
-`/bin/cc` and `/bin/c++`. Keep `-c` when switching compilers to clear the old
-configuration.
-
 The amd64 binary is written to `build/linux/x86_64/release/crossdesk`; the arm64 binary is written to `build/linux/arm64/release/crossdesk`.
 
 Example configuration with Wayland and DRM capture enabled:
 
 ```bash
-xmake f -c -m release --USE_WAYLAND=true --USE_DRM=true --USE_CUDA=false \
-  --toolchain=gcc-10 -y
+xmake f -m release --USE_WAYLAND=true --USE_DRM=true --USE_CUDA=false \
+  --cc=gcc-10 --cxx=g++-10 -y
 xmake b -vy crossdesk
 ```
 

src/common/windows_input_marker.h

@@ -1,15 +0,0 @@
-#ifndef CROSSDESK_COMMON_WINDOWS_INPUT_MARKER_H_
-#define CROSSDESK_COMMON_WINDOWS_INPUT_MARKER_H_
-
-#include <cstdint>
-
-namespace crossdesk {
-
-// SendInput copies dwExtraInfo into KBDLLHOOKSTRUCT. Tag CrossDesk-generated
-// keyboard input so the controller hook can ignore only its own injections
-// while still accepting input from accessibility tools or remote sessions.
-inline constexpr std::uintptr_t kInjectedKeyboardInputMarker = 0x4353444B;
-
-}  // namespace crossdesk
-
-#endif  // CROSSDESK_COMMON_WINDOWS_INPUT_MARKER_H_

src/device_controller/keyboard/linux/keyboard_capturer.cpp

@@ -8,7 +8,6 @@
 #include <poll.h>
 
 #include "keyboard_converter.h"
-#include "linux_evdev_keycode.h"
 #include "platform.h"
 #include "rd_log.h"
 #include "windows_key_metadata.h"
@@ -18,40 +17,6 @@ namespace crossdesk {
 static OnKeyAction g_on_key_action = nullptr;
 static void* g_user_ptr = nullptr;
 
-static KeyCode ResolveX11Keycode(Display* display, int key_code,
-                                 uint32_t scan_code, bool extended) {
-  if (!display) {
-    return 0;
-  }
-
-  const auto key_it = vkCodeToX11KeySym.find(key_code);
-  if (key_it != vkCodeToX11KeySym.end()) {
-    const KeyCode x11_keycode =
-        XKeysymToKeycode(display, static_cast<KeySym>(key_it->second));
-    if (x11_keycode != 0) {
-      return x11_keycode;
-    }
-  }
-
-  // Some controllers can preserve the physical Windows scan code even when
-  // they cannot resolve a Windows virtual-key value. Xorg's evdev keycodes use
-  // the Linux input code plus the protocol-reserved offset of 8.
-  const int evdev_keycode =
-      ResolveLinuxEvdevKeycodeFromWindowsKey(key_code, scan_code, extended);
-  if (evdev_keycode < 0) {
-    return 0;
-  }
-
-  int min_keycode = 0;
-  int max_keycode = 0;
-  XDisplayKeycodes(display, &min_keycode, &max_keycode);
-  const int x11_keycode = evdev_keycode + 8;
-  if (x11_keycode < min_keycode || x11_keycode > max_keycode) {
-    return 0;
-  }
-  return static_cast<KeyCode>(x11_keycode);
-}
-
 static KeySym NormalizeKeySym(KeySym key_sym) {
   if (key_sym >= XK_a && key_sym <= XK_z) {
     return key_sym - XK_a + XK_A;
@@ -97,16 +62,7 @@ KeyboardCapturer::KeyboardCapturer()
   display_ = XOpenDisplay(nullptr);
   if (!display_) {
     LOG_ERROR("Failed to open X display.");
-    return;
   }
-
-  int event_base = 0;
-  int error_base = 0;
-  int major_version = 0;
-  int minor_version = 0;
-  x11_xtest_available_ =
-      XTestQueryExtension(display_, &event_base, &error_base, &major_version,
-                          &minor_version) != 0;
 }
 
 KeyboardCapturer::~KeyboardCapturer() {
@@ -114,10 +70,8 @@ KeyboardCapturer::~KeyboardCapturer() {
   CleanupWaylandPortal();
 
   if (display_) {
-    std::lock_guard<std::mutex> lock(x11_injection_mutex_);
     XCloseDisplay(display_);
     display_ = nullptr;
-    x11_xtest_available_ = false;
   }
 }
 
@@ -202,6 +156,8 @@ int KeyboardCapturer::Unhook() {
 
 int KeyboardCapturer::SendKeyboardCommand(int key_code, bool is_down,
                                           uint32_t scan_code, bool extended) {
+  (void)scan_code;
+  (void)extended;
   if (IsWaylandSession()) {
     if (!use_wayland_portal_ && !wayland_init_attempted_) {
       wayland_init_attempted_ = true;
@@ -225,33 +181,12 @@ int KeyboardCapturer::SendKeyboardCommand(int key_code, bool is_down,
     return -1;
   }
 
-  std::lock_guard<std::mutex> lock(x11_injection_mutex_);
-  if (!x11_xtest_available_) {
-    LOG_ERROR("XTest extension not available for keyboard injection");
-    return -2;
+  if (vkCodeToX11KeySym.find(key_code) != vkCodeToX11KeySym.end()) {
+    int x11_key_code = vkCodeToX11KeySym[key_code];
+    KeyCode keycode = XKeysymToKeycode(display_, x11_key_code);
+    XTestFakeKeyEvent(display_, keycode, is_down, CurrentTime);
+    XFlush(display_);
   }
-
-  const KeyCode x11_keycode =
-      ResolveX11Keycode(display_, key_code, scan_code, extended);
-  if (x11_keycode == 0) {
-    LOG_WARN(
-        "Cannot map remote keyboard event to X11 keycode, vk_code={}, "
-        "scan_code={}, extended={}",
-        key_code, scan_code, extended);
-    return -3;
-  }
-
-  if (!XTestFakeKeyEvent(display_, x11_keycode, is_down, CurrentTime)) {
-    LOG_ERROR(
-        "XTest keyboard injection failed, vk_code={}, scan_code={}, "
-        "extended={}, x11_keycode={}, is_down={}",
-        key_code, scan_code, extended, static_cast<int>(x11_keycode), is_down);
-    return -4;
-  }
-
-  // Complete the request before reporting success to the keyboard-state
-  // reconciler. This also makes X11 protocol errors observable immediately.
-  XSync(display_, False);
   return 0;
 }
 }  // namespace crossdesk

src/device_controller/keyboard/linux/keyboard_capturer.h

@@ -10,7 +10,6 @@
 #include <atomic>
 #include <cstdint>
 #include <functional>
-#include <mutex>
 #include <string>
 #include <thread>
 
@@ -50,8 +49,6 @@ class KeyboardCapturer : public DeviceController {
   unsigned long root_;
   std::atomic<bool> running_;
   std::thread event_thread_;
-  std::mutex x11_injection_mutex_;
-  bool x11_xtest_available_ = false;
   bool use_wayland_portal_ = false;
   bool wayland_init_attempted_ = false;
   DBusConnection* dbus_connection_ = nullptr;

src/device_controller/keyboard/linux/keyboard_capturer_wayland.cpp

@@ -611,7 +611,6 @@ int KeyboardCapturer::SendWaylandKeyboardCommand(int key_code, bool is_down,
   // Prefer keycode injection to preserve physical-key semantics and avoid
   // implicit Shift interpretation for uppercase keysyms.
   if (display_) {
-    std::lock_guard<std::mutex> lock(x11_injection_mutex_);
     const int keysym = key_it->second;
     const KeyCode x11_keycode =
         XKeysymToKeycode(display_, static_cast<KeySym>(keysym));

src/device_controller/keyboard/windows/keyboard_capturer.cpp

@@ -1,17 +1,36 @@
 #include "keyboard_capturer.h"
 
-#include <hidusage.h>
-
 #include "rd_log.h"
-#include "windows_input_marker.h"
 
 namespace crossdesk {
-namespace {
 
-constexpr wchar_t kRawInputWindowClassName[] =
-    L"CrossDeskKeyboardRawInputWindow";
+static OnKeyAction g_on_key_action = nullptr;
+static void* g_user_ptr = nullptr;
 
-bool PreferSideSpecificVkInjection(int key_code) {
+static int NormalizeModifierVkCode(const KBDLLHOOKSTRUCT* kb_data) {
+  if (kb_data == nullptr) {
+    return -1;
+  }
+
+  if (kb_data->vkCode != VK_SHIFT && kb_data->vkCode != VK_CONTROL &&
+      kb_data->vkCode != VK_MENU) {
+    return static_cast<int>(kb_data->vkCode);
+  }
+
+  UINT scan_code = static_cast<UINT>(kb_data->scanCode & 0xFF);
+  if ((kb_data->flags & LLKHF_EXTENDED) != 0) {
+    scan_code |= 0xE000;
+  }
+
+  const UINT normalized_vk = MapVirtualKeyW(scan_code, MAPVK_VSC_TO_VK_EX);
+  if (normalized_vk != 0) {
+    return static_cast<int>(normalized_vk);
+  }
+
+  return static_cast<int>(kb_data->vkCode);
+}
+
+static bool PreferSideSpecificVkInjection(int key_code) {
   switch (key_code) {
     case VK_LSHIFT:
     case VK_RSHIFT:
@@ -27,247 +46,58 @@ bool PreferSideSpecificVkInjection(int key_code) {
   }
 }
 
-}  // namespace
+LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
+  if (nCode == HC_ACTION && g_on_key_action) {
+    KBDLLHOOKSTRUCT* kbData = reinterpret_cast<KBDLLHOOKSTRUCT*>(lParam);
+    if ((kbData->flags & LLKHF_INJECTED) != 0) {
+      return CallNextHookEx(NULL, nCode, wParam, lParam);
+    }
+    const int key_code = NormalizeModifierVkCode(kbData);
+
+    if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) {
+      g_on_key_action(key_code, true, kbData->scanCode,
+                      (kbData->flags & LLKHF_EXTENDED) != 0, g_user_ptr);
+    } else if (wParam == WM_KEYUP || wParam == WM_SYSKEYUP) {
+      g_on_key_action(key_code, false, kbData->scanCode,
+                      (kbData->flags & LLKHF_EXTENDED) != 0, g_user_ptr);
+    }
+    return 1;
+  }
+
+  return CallNextHookEx(NULL, nCode, wParam, lParam);
+}
 
 KeyboardCapturer::KeyboardCapturer() {}
 
-KeyboardCapturer::~KeyboardCapturer() { Unhook(); }
+KeyboardCapturer::~KeyboardCapturer() {}
 
 int KeyboardCapturer::Hook(OnKeyAction on_key_action, void* user_ptr) {
-  if (capture_thread_.joinable()) {
-    return 0;
-  }
+  g_on_key_action = on_key_action;
+  g_user_ptr = user_ptr;
 
-  on_key_action_ = on_key_action;
-  user_ptr_ = user_ptr;
-  {
-    std::lock_guard<std::mutex> lock(capture_state_mutex_);
-    capture_thread_id_ = 0;
-    capture_start_complete_ = false;
-    capture_start_succeeded_ = false;
-  }
-
-  capture_thread_ = std::thread(&KeyboardCapturer::RawInputThreadMain, this);
-
-  std::unique_lock<std::mutex> lock(capture_state_mutex_);
-  capture_start_condition_.wait(
-      lock, [this] { return capture_start_complete_; });
-  const bool capture_started = capture_start_succeeded_;
-  lock.unlock();
-
-  if (!capture_started) {
-    if (capture_thread_.joinable()) {
-      capture_thread_.join();
-    }
-    on_key_action_ = nullptr;
-    user_ptr_ = nullptr;
+  keyboard_hook_ = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardProc, NULL, 0);
+  if (!keyboard_hook_) {
+    LOG_ERROR("Failed to install keyboard hook");
     return -1;
   }
   return 0;
 }
 
 int KeyboardCapturer::Unhook() {
-  DWORD capture_thread_id = 0;
-  {
-    std::lock_guard<std::mutex> lock(capture_state_mutex_);
-    capture_thread_id = capture_thread_id_;
+  if (keyboard_hook_) {
+    g_on_key_action = nullptr;
+    g_user_ptr = nullptr;
+    UnhookWindowsHookEx(keyboard_hook_);
+    keyboard_hook_ = nullptr;
   }
-  if (capture_thread_id != 0 &&
-      !PostThreadMessageW(capture_thread_id, WM_QUIT, 0, 0)) {
-    LOG_WARN("Failed to stop keyboard raw input thread, thread_id={}, error={}",
-             capture_thread_id, GetLastError());
-  }
-  if (capture_thread_.joinable()) {
-    capture_thread_.join();
-  }
-
-  on_key_action_ = nullptr;
-  user_ptr_ = nullptr;
   return 0;
 }
 
-void KeyboardCapturer::RawInputThreadMain() {
-  const DWORD thread_id = GetCurrentThreadId();
-
-  MSG message{};
-  PeekMessageW(&message, nullptr, WM_USER, WM_USER, PM_NOREMOVE);
-  const bool capture_started = CreateRawInputWindow();
-  {
-    std::lock_guard<std::mutex> lock(capture_state_mutex_);
-    capture_thread_id_ = thread_id;
-    capture_start_succeeded_ = capture_started;
-    capture_start_complete_ = true;
-  }
-  capture_start_condition_.notify_one();
-
-  if (!capture_started) {
-    std::lock_guard<std::mutex> lock(capture_state_mutex_);
-    capture_thread_id_ = 0;
-    return;
-  }
-
-  LOG_INFO("Keyboard raw input capture started, thread_id={}", thread_id);
-  while (true) {
-    const BOOL get_message_result = GetMessageW(&message, nullptr, 0, 0);
-    if (get_message_result <= 0) {
-      if (get_message_result < 0) {
-        LOG_WARN("Keyboard raw input message loop failed, thread_id={}, "
-                 "error={}",
-                 thread_id, GetLastError());
-      }
-      break;
-    }
-    TranslateMessage(&message);
-    DispatchMessageW(&message);
-  }
-
-  DestroyRawInputWindow();
-  {
-    std::lock_guard<std::mutex> lock(capture_state_mutex_);
-    capture_thread_id_ = 0;
-  }
-  LOG_INFO("Keyboard raw input capture stopped, thread_id={}", thread_id);
-}
-
-bool KeyboardCapturer::CreateRawInputWindow() {
-  const HINSTANCE instance = GetModuleHandleW(nullptr);
-  WNDCLASSEXW window_class{};
-  window_class.cbSize = sizeof(window_class);
-  window_class.lpfnWndProc = &KeyboardCapturer::RawInputWindowProc;
-  window_class.hInstance = instance;
-  window_class.lpszClassName = kRawInputWindowClassName;
-
-  if (RegisterClassExW(&window_class) == 0) {
-    const DWORD error = GetLastError();
-    if (error != ERROR_CLASS_ALREADY_EXISTS) {
-      LOG_WARN("Failed to register keyboard raw input window class, error={}",
-               error);
-      return false;
-    }
-  }
-
-  raw_input_window_ = CreateWindowExW(
-      0, kRawInputWindowClassName, L"", 0, 0, 0, 0, 0, HWND_MESSAGE, nullptr,
-      instance, this);
-  if (!raw_input_window_) {
-    LOG_WARN("Failed to create keyboard raw input window, error={}",
-             GetLastError());
-    return false;
-  }
-
-  RAWINPUTDEVICE keyboard_device{};
-  keyboard_device.usUsagePage = HID_USAGE_PAGE_GENERIC;
-  keyboard_device.usUsage = HID_USAGE_GENERIC_KEYBOARD;
-  keyboard_device.dwFlags = RIDEV_DEVNOTIFY | RIDEV_INPUTSINK;
-  keyboard_device.hwndTarget = raw_input_window_;
-  if (!RegisterRawInputDevices(&keyboard_device, 1,
-                               sizeof(keyboard_device))) {
-    LOG_WARN("Failed to register keyboard raw input, error={}", GetLastError());
-    DestroyWindow(raw_input_window_);
-    raw_input_window_ = nullptr;
-    return false;
-  }
-
-  raw_input_registered_ = true;
-  return true;
-}
-
-void KeyboardCapturer::DestroyRawInputWindow() {
-  if (raw_input_registered_) {
-    RAWINPUTDEVICE keyboard_device{};
-    keyboard_device.usUsagePage = HID_USAGE_PAGE_GENERIC;
-    keyboard_device.usUsage = HID_USAGE_GENERIC_KEYBOARD;
-    keyboard_device.dwFlags = RIDEV_REMOVE;
-    keyboard_device.hwndTarget = nullptr;
-    if (!RegisterRawInputDevices(&keyboard_device, 1,
-                                 sizeof(keyboard_device))) {
-      LOG_WARN("Failed to unregister keyboard raw input, error={}",
-               GetLastError());
-    }
-    raw_input_registered_ = false;
-  }
-  if (raw_input_window_) {
-    DestroyWindow(raw_input_window_);
-    raw_input_window_ = nullptr;
-  }
-}
-
-LRESULT CALLBACK KeyboardCapturer::RawInputWindowProc(
-    HWND window, UINT message, WPARAM w_param, LPARAM l_param) {
-  KeyboardCapturer* capturer = reinterpret_cast<KeyboardCapturer*>(
-      GetWindowLongPtrW(window, GWLP_USERDATA));
-  if (message == WM_NCCREATE) {
-    auto* create = reinterpret_cast<CREATESTRUCTW*>(l_param);
-    capturer = static_cast<KeyboardCapturer*>(create->lpCreateParams);
-    SetWindowLongPtrW(window, GWLP_USERDATA,
-                      reinterpret_cast<LONG_PTR>(capturer));
-  } else if (message == WM_INPUT && capturer) {
-    capturer->HandleRawInput(reinterpret_cast<HRAWINPUT>(l_param));
-  } else if (message == WM_NCDESTROY) {
-    SetWindowLongPtrW(window, GWLP_USERDATA, 0);
-  }
-  return DefWindowProcW(window, message, w_param, l_param);
-}
-
-void KeyboardCapturer::HandleRawInput(HRAWINPUT raw_input_handle) {
-  RAWINPUT input{};
-  UINT input_size = sizeof(input);
-  const UINT bytes_read =
-      GetRawInputData(raw_input_handle, RID_INPUT, &input, &input_size,
-                      sizeof(RAWINPUTHEADER));
-  if (bytes_read == static_cast<UINT>(-1) ||
-      bytes_read < sizeof(RAWINPUTHEADER) ||
-      input.header.dwType != RIM_TYPEKEYBOARD) {
-    return;
-  }
-
-  const RAWKEYBOARD& keyboard = input.data.keyboard;
-  if (keyboard.VKey == 0xFF ||
-      keyboard.ExtraInformation ==
-          static_cast<ULONG>(kInjectedKeyboardInputMarker)) {
-    return;
-  }
-
-  bool is_down = false;
-  if (keyboard.Message == WM_KEYDOWN || keyboard.Message == WM_SYSKEYDOWN) {
-    is_down = true;
-  } else if (keyboard.Message != WM_KEYUP &&
-             keyboard.Message != WM_SYSKEYUP) {
-    return;
-  }
-
-  const bool extended = (keyboard.Flags & (RI_KEY_E0 | RI_KEY_E1)) != 0;
-  UINT mapped_scan_code = keyboard.MakeCode;
-  if ((keyboard.Flags & RI_KEY_E0) != 0) {
-    mapped_scan_code |= 0xE000;
-  } else if ((keyboard.Flags & RI_KEY_E1) != 0) {
-    mapped_scan_code |= 0xE100;
-  }
-  if (mapped_scan_code == 0xE11D || mapped_scan_code == 0xE02A) {
-    return;
-  }
-
-  int key_code = static_cast<int>(keyboard.VKey);
-  if (key_code == VK_SHIFT || key_code == VK_CONTROL || key_code == VK_MENU) {
-    const UINT normalized =
-        MapVirtualKeyW(mapped_scan_code, MAPVK_VSC_TO_VK_EX);
-    if (normalized != 0) {
-      key_code = static_cast<int>(normalized);
-    }
-  }
-
-  if (on_key_action_) {
-    on_key_action_(key_code, is_down, keyboard.MakeCode, extended, user_ptr_);
-  }
-}
-
-// Apply remote keyboard commands to the local machine.
+// apply remote keyboard commands to the local machine
 int KeyboardCapturer::SendKeyboardCommand(int key_code, bool is_down,
                                           uint32_t scan_code, bool extended) {
   INPUT input = {0};
   input.type = INPUT_KEYBOARD;
-  input.ki.dwExtraInfo =
-      static_cast<ULONG_PTR>(kInjectedKeyboardInputMarker);
 
   const bool prefer_vk = PreferSideSpecificVkInjection(key_code);
   const UINT resolved_scan_code =
@@ -283,7 +113,7 @@ int KeyboardCapturer::SendKeyboardCommand(int key_code, bool is_down,
       input.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
     }
   } else {
-    input.ki.wVk = static_cast<WORD>(key_code);
+    input.ki.wVk = (WORD)key_code;
 
     if (prefer_vk && resolved_scan_code != 0) {
       input.ki.wScan = static_cast<WORD>(resolved_scan_code & 0xFF);
@@ -304,7 +134,7 @@ int KeyboardCapturer::SendKeyboardCommand(int key_code, bool is_down,
     input.ki.dwFlags |= KEYEVENTF_KEYUP;
   }
 
-  const UINT sent = SendInput(1, &input, sizeof(INPUT));
+  UINT sent = SendInput(1, &input, sizeof(INPUT));
   if (sent != 1) {
     LOG_WARN("SendInput failed for key_code={}, is_down={}, err={}", key_code,
              is_down, GetLastError());

src/device_controller/keyboard/windows/keyboard_capturer.h

@@ -9,10 +9,6 @@
 
 #include <Windows.h>
 
-#include <condition_variable>
-#include <mutex>
-#include <thread>
-
 #include "device_controller.h"
 
 namespace crossdesk {
@@ -30,24 +26,7 @@ class KeyboardCapturer : public DeviceController {
                                   bool extended = false);
 
  private:
-  static LRESULT CALLBACK RawInputWindowProc(HWND window, UINT message,
-                                             WPARAM w_param, LPARAM l_param);
-
-  void RawInputThreadMain();
-  bool CreateRawInputWindow();
-  void DestroyRawInputWindow();
-  void HandleRawInput(HRAWINPUT raw_input_handle);
-
-  OnKeyAction on_key_action_ = nullptr;
-  void* user_ptr_ = nullptr;
-  HWND raw_input_window_ = nullptr;
-  bool raw_input_registered_ = false;
-  std::thread capture_thread_;
-  DWORD capture_thread_id_ = 0;
-  bool capture_start_complete_ = false;
-  bool capture_start_succeeded_ = false;
-  std::mutex capture_state_mutex_;
-  std::condition_variable capture_start_condition_;
+  HHOOK keyboard_hook_ = nullptr;
 };
 }  // namespace crossdesk
 

src/gui/application/gui_application.cpp

@@ -943,6 +943,10 @@ void GuiApplication::InitializeSettings() {
 
 bool GuiApplication::InitializeSDL() {
 #if defined(__linux__) && !defined(__APPLE__)
+  if (!getenv("SDL_AUDIODRIVER")) {
+    setenv("SDL_AUDIODRIVER", "pulseaudio", 0);
+  }
+
   // Standard Wayland top-level windows cannot choose an absolute screen
   // position. Use the session's XWayland compatibility server for the GUI so
   // auxiliary windows such as the controlled-side status window can be
@@ -966,14 +970,6 @@ bool GuiApplication::InitializeSDL() {
     LOG_ERROR("SDL initialization failed: {}", SDL_GetError());
     return false;
   }
-#if defined(__linux__) && !defined(__APPLE__)
-  const char* active_video_driver = SDL_GetCurrentVideoDriver();
-  // X11 permits the manual move/position operations used by the frameless
-  // main window. Keep native Wayland decorations as a compatibility fallback.
-  use_x11_custom_titlebar_ =
-      active_video_driver != nullptr &&
-      std::strcmp(active_video_driver, "x11") == 0;
-#endif
 
   if (const SDL_DisplayMode* mode = SDL_GetCurrentDisplayMode(0)) {
     screen_width_ = mode->w;
@@ -1008,8 +1004,10 @@ void GuiApplication::InitializeUi() {
 #if _WIN32
   ui_->main->set_custom_titlebar(true);
 #elif defined(__linux__)
-  ui_->main->set_custom_titlebar(use_x11_custom_titlebar_);
-  ui_->main->set_wayland_titlebar(use_xwayland_gui_);
+  if (use_xwayland_gui_) {
+    ui_->main->set_custom_titlebar(true);
+    ui_->main->set_wayland_titlebar(true);
+  }
 #endif
   std::vector<ui::ReleaseNoteBlock> release_note_blocks;
   for (const auto& parsed : ParseReleaseNotesMarkdownForSlint(release_notes_)) {
@@ -3042,8 +3040,9 @@ void GuiApplication::SendKeyInput(const std::string& text, bool pressed,
   controlled_remote_id_ = props->remote_id_;
   focused_remote_id_ = props->remote_id_;
 
-  // Native capture forwards the event independently. Slint keyboard events
-  // are used only by platforms whose native capture backend is unavailable.
+  // Native hooks see the same physical key before Slint does. When a native
+  // hook is active, forwarding the FocusScope callback as well would duplicate
+  // the event on platforms whose hook does not consume the local key.
   if (keyboard_capturer_is_started_ && !keyboard_capturer_uses_window_events_) {
     return;
   }

src/gui/application/gui_application.h

@@ -66,7 +66,6 @@ private:
   std::unique_ptr<SlintUi> ui_;
 #if defined(__linux__) && !defined(__APPLE__)
   bool use_xwayland_gui_ = false;
-  bool use_x11_custom_titlebar_ = false;
 #endif
 };
 

src/gui/features/devices/session_device_manager.cpp

@@ -11,7 +11,6 @@ namespace crossdesk {
 namespace {
 
 constexpr uint64_t kCaptureResumeKeyFrameGapMs = 500;
-constexpr size_t kMaxCapturedKeyboardInputs = 512;
 
 } // namespace
 
@@ -257,18 +256,18 @@ int SessionDeviceManager::StartKeyboardCapturer() {
       [](int key_code, bool is_down, uint32_t scan_code, bool extended,
          void *user_ptr) {
         if (user_ptr) {
-          auto *devices = static_cast<SessionDeviceManager *>(user_ptr);
-          devices->QueueCapturedKeyboardInput(key_code, is_down, scan_code,
+          auto *runtime = static_cast<GuiRuntime *>(user_ptr);
+          runtime->keyboard_.SendKeyCommand(key_code, is_down, scan_code,
                                            extended);
         }
       },
-      this);
+      &owner_);
   if (hook_ret != 0) {
     owner_.keyboard_capturer_uses_window_events_ = true;
     LOG_WARN(
         "Start keyboard capturer failed, falling back to Slint keyboard events");
   } else {
-    LOG_INFO("Start keyboard capturer with native input");
+    LOG_INFO("Start keyboard capturer with native hook");
   }
   return 0;
 }
@@ -282,7 +281,6 @@ int SessionDeviceManager::StopKeyboardCapturer() {
 
   if (keyboard_capturer_) {
     keyboard_capturer_->Unhook();
-    ClearCapturedKeyboardInput();
     LOG_INFO("Stop keyboard capturer");
   }
   return 0;
@@ -412,7 +410,6 @@ void SessionDeviceManager::UpdateInteractions() {
       owner_.keyboard_capturer_is_started_ = true;
     }
     if (owner_.keyboard_capturer_is_started_) {
-      DrainCapturedKeyboardInput();
       owner_.keyboard_.SendHeartbeat(false);
     }
   } else if (owner_.keyboard_capturer_is_started_) {
@@ -424,36 +421,6 @@ void SessionDeviceManager::UpdateInteractions() {
   owner_.keyboard_.CheckRemoteTimeouts();
 }
 
-void SessionDeviceManager::QueueCapturedKeyboardInput(int key_code,
-                                                       bool is_down,
-                                                       uint32_t scan_code,
-                                                       bool extended) {
-  std::lock_guard<std::mutex> lock(captured_keyboard_inputs_mutex_);
-  if (captured_keyboard_inputs_.size() >= kMaxCapturedKeyboardInputs) {
-    captured_keyboard_inputs_.pop_front();
-    LOG_WARN("Captured keyboard input queue overflow, dropping oldest event");
-  }
-  captured_keyboard_inputs_.push_back(
-      CapturedKeyboardInput{key_code, is_down, scan_code, extended});
-}
-
-void SessionDeviceManager::DrainCapturedKeyboardInput() {
-  std::deque<CapturedKeyboardInput> inputs;
-  {
-    std::lock_guard<std::mutex> lock(captured_keyboard_inputs_mutex_);
-    inputs.swap(captured_keyboard_inputs_);
-  }
-  for (const CapturedKeyboardInput &input : inputs) {
-    owner_.keyboard_.SendKeyCommand(input.key_code, input.is_down,
-                                    input.scan_code, input.extended);
-  }
-}
-
-void SessionDeviceManager::ClearCapturedKeyboardInput() {
-  std::lock_guard<std::mutex> lock(captured_keyboard_inputs_mutex_);
-  captured_keyboard_inputs_.clear();
-}
-
 bool SessionDeviceManager::SendKeyboardCommand(int key_code, bool is_down,
                                                uint32_t scan_code,
                                                bool extended) {

src/gui/features/devices/session_device_manager.h

@@ -5,8 +5,6 @@
 
 #include <cstddef>
 #include <cstdint>
-#include <deque>
-#include <mutex>
 #include <string>
 #include <vector>
 
@@ -55,18 +53,6 @@ public:
   const std::vector<DisplayInfo> &display_info_list() const;
 
 private:
-  struct CapturedKeyboardInput {
-    int key_code = 0;
-    bool is_down = false;
-    uint32_t scan_code = 0;
-    bool extended = false;
-  };
-
-  void QueueCapturedKeyboardInput(int key_code, bool is_down,
-                                  uint32_t scan_code, bool extended);
-  void DrainCapturedKeyboardInput();
-  void ClearCapturedKeyboardInput();
-
   GuiRuntime &owner_;
   SDL_AudioStream *output_stream_ = nullptr;
   ScreenCapturerFactory *screen_capturer_factory_ = nullptr;
@@ -77,8 +63,6 @@ private:
   MouseController *mouse_controller_ = nullptr;
   KeyboardCapturer *keyboard_capturer_ = nullptr;
   std::vector<DisplayInfo> display_info_list_;
-  std::deque<CapturedKeyboardInput> captured_keyboard_inputs_;
-  std::mutex captured_keyboard_inputs_mutex_;
   uint64_t last_frame_time_ = 0;
   std::string last_video_frame_stream_id_;
 };

src/gui/features/input/keyboard_controller.cpp

@@ -1,14 +1,14 @@
 #include "features/input/keyboard_controller.h"
 
-#include <SDL3/SDL.h>
-
 #include <cstdint>
 #include <mutex>
-#include <nlohmann/json.hpp>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
+#include <SDL3/SDL.h>
+#include <nlohmann/json.hpp>
+
 #include "minirtc.h"
 #include "rd_log.h"
 #include "runtime/gui_runtime.h"
@@ -223,8 +223,7 @@ bool KeyboardController::InjectRemoteKey(int key_code, bool is_down,
       action.k.flag = is_down ? KeyFlag::key_down : KeyFlag::key_up;
       if (!json.is_discarded() &&
           IsTransientSecureDesktopInputFailure(json, action)) {
-        LOG_INFO(
-            "Secure desktop keyboard injection transient failure, "
+        LOG_INFO("Secure desktop keyboard injection transient failure, "
                  "key_code={}, is_down={}, response={}",
                  key_code, is_down, response);
         return true;

src/gui/ui/main_window.slint

@@ -601,15 +601,6 @@ export component MainWindow inherits Window {
                                 border-width: 1px;
                                 border-color: ImGuiLineStyle.border;
                                 border-radius: 4px;
-                                // Measure the ID using the preferred field size.
-                                // The visible text can then scale only on systems
-                                // whose font metrics would otherwise clip it.
-                                local-id-width-probe := Text {
-                                    visible: false;
-                                    text: root.local-id;
-                                    font-size: ImGuiFontStyle.field-value;
-                                    letter-spacing: 1px;
-                                }
                                 Text {
                                     x: 8px;
                                     // Compensate for the font's ascender-heavy
@@ -619,9 +610,7 @@ export component MainWindow inherits Window {
                                     height: parent.height - 4px;
                                     text: root.local-id;
                                     color: #20242a;
-                                    font-size: max(18px,
-                                        ImGuiFontStyle.field-value *
-                                        (self.width / max(self.width, local-id-width-probe.preferred-width)));
+                                    font-size: ImGuiFontStyle.field-value;
                                     letter-spacing: 1px;
                                     horizontal-alignment: left;
                                     vertical-alignment: center;

src/service/windows/session_helper_main.cpp

@@ -24,7 +24,6 @@
 #include "path_manager.h"
 #include "rd_log.h"
 #include "session_helper_shared.h"
-#include "windows_input_marker.h"
 
 namespace {
 
@@ -829,8 +828,6 @@ InputInjectionResult InjectKeyboardInput(
 
   INPUT input = {0};
   input.type = INPUT_KEYBOARD;
-  input.ki.dwExtraInfo = static_cast<ULONG_PTR>(
-      crossdesk::kInjectedKeyboardInputMarker);
 
   const bool prefer_vk = PreferSideSpecificVkInjection(key_code);
   const UINT resolved_scan_code =

tests/linux_keyboard_x11_integration_test.cpp

@@ -1,52 +0,0 @@
-#include <X11/Xlib.h>
-
-#include <chrono>
-#include <cstdio>
-#include <thread>
-
-#include "keyboard_capturer.h"
-
-int main() {
-  Display* receiver = XOpenDisplay(nullptr);
-  if (!receiver) {
-    std::fprintf(stderr, "open display failed\n");
-    return 1;
-  }
-
-  const int screen = DefaultScreen(receiver);
-  Window window = XCreateSimpleWindow(receiver, RootWindow(receiver, screen),
-                                      0, 0, 100, 100, 0, 0, 0);
-  XSelectInput(receiver, window, KeyPressMask | KeyReleaseMask);
-  XMapWindow(receiver, window);
-  XSync(receiver, False);
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
-  XSetInputFocus(receiver, window, RevertToParent, CurrentTime);
-  XSync(receiver, False);
-
-  crossdesk::KeyboardCapturer keyboard;
-  // Exercise the scan-code fallback: the controller supplied no usable VK,
-  // but did preserve the set-1 scan code for the A key.
-  const int down = keyboard.SendKeyboardCommand(0, true, 0x1E, false);
-  const int up = keyboard.SendKeyboardCommand(0, false, 0x1E, false);
-
-  bool saw_down = false;
-  bool saw_up = false;
-  const auto deadline = std::chrono::steady_clock::now() +
-                        std::chrono::seconds(2);
-  while (std::chrono::steady_clock::now() < deadline &&
-         (!saw_down || !saw_up)) {
-    while (XPending(receiver) > 0) {
-      XEvent event{};
-      XNextEvent(receiver, &event);
-      saw_down = saw_down || event.type == KeyPress;
-      saw_up = saw_up || event.type == KeyRelease;
-    }
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-  }
-
-  XDestroyWindow(receiver, window);
-  XCloseDisplay(receiver);
-  std::printf("down_ret=%d up_ret=%d saw_down=%d saw_up=%d\n", down, up,
-              saw_down, saw_up);
-  return down == 0 && up == 0 && saw_down && saw_up ? 0 : 2;
-}

thirdparty/slint/xmake.lua

@@ -9,13 +9,10 @@ package("slint")
 
     add_configs("shared", {description = "Build the Slint runtime as a shared library", default = true, type = "boolean", readonly = true})
 
-    add_deps("cmake~slint >=3.21 <4.0", {host = true, private = true, system = false})
+    add_deps("cmake")
     add_deps("rust 1.92.0", {host = true, private = true, system = false})
 
     on_load(function(package)
-        if package:is_plat("linux") then
-            package:add("deps", "fontconfig", {private = true, system = false})
-        end
         package:add("includedirs", "include/slint")
         if package:is_plat("windows") then
             package:add("links", "slint_cpp.dll")
@@ -25,13 +22,6 @@ package("slint")
     end)
 
     on_install("windows", "linux", "macosx", function(package)
-        for _, dep in ipairs(package:orderdeps()) do
-            if dep:name() == "cmake" and dep:label() == "slint" then
-                os.addenv("PATH", dep:installdir("bin"))
-                import("core.cache.detectcache"):set2("find_program", "cmake", nil)
-                break
-            end
-        end
         local configs = {
             "-DSLINT_BUILD_TESTING=OFF",
             "-DSLINT_BUILD_EXAMPLES=OFF",
@@ -49,12 +39,6 @@ package("slint")
             "-DSLINT_STYLE=fluent",
             "-DBUILD_SHARED_LIBS=ON"
         }
-        if package:is_plat("windows") then
-            local rc = assert(package:build_getenv("mrc"),
-                "failed to find the Windows resource compiler")
-            rc = rc:gsub("\\", "/")
-            table.insert(configs, "-DCMAKE_RC_COMPILER=" .. rc)
-        end
         import("package.tools.cmake").install(package, configs)
     end)
 

xmake/options.lua

@@ -51,7 +51,7 @@ function setup_options_and_dependencies()
         add_defines("CROSSDESK_DEBUG")
     end
 
-    add_requireconfs("**.python", {version = "3.12", override = true, configs = {pgo = false}})
+    add_requireconfs("*.python", {version = "3.12", override = true, configs = {pgo = false}})
     add_requires("spdlog 1.14.1", {system = false})
     add_requires("slint 1.17.1", {configs = {shared = true}})
     add_requires("libsdl3 3.2.26", {configs = {shared = false}})

xmake/targets.lua

@@ -197,14 +197,6 @@ function setup_targets()
                 "src/device_controller/keyboard/linux", {public = true})
         end
 
-    if is_os("linux") then
-        target("linux_keyboard_x11_integration_test")
-            set_kind("binary")
-            set_default(false)
-            add_deps("device_controller")
-            add_files("tests/linux_keyboard_x11_integration_test.cpp")
-    end
-
     target("thumbnail")
         set_kind("object")
         add_packages("libyuv", "openssl3")
@@ -315,7 +307,7 @@ function setup_targets()
             add_links("Advapi32", "User32", "Wtsapi32", "Gdi32")
             add_files("src/service/windows/session_helper_main.cpp")
             add_files(crossdesk_windows_resource)
-            add_includedirs("src/common", "src/service/windows", {public = true})
+            add_includedirs("src/service/windows", {public = true})
     end
 
     target("crossdesk")