[refactor] reorganize platform and wire sources

apps/desktop/src/gui/features/clipboard/clipboard_controller.cpp

@@ -0,0 +1,172 @@
+#include "features/clipboard/clipboard_controller.h"
+
+#include <cstring>
+#include <shared_mutex>
+#include <utility>
+
+#include "rd_log.h"
+#include "runtime/gui_runtime.h"
+
+namespace crossdesk {
+namespace {
+
+// Keep a reliable clipboard message within MiniRTC/KCP's single-message
+// fragmentation window (MTU is configured to 1200 bytes).
+constexpr size_t kMaxClipboardTextBytes = 128 * 1024;
+
+} // namespace
+
+ClipboardController::ClipboardController(GuiRuntime &owner) : owner_(owner) {}
+
+void ClipboardController::SetEventType(uint32_t event_type) {
+  event_type_ = event_type;
+}
+
+uint32_t ClipboardController::event_type() const { return event_type_; }
+
+void ClipboardController::Initialize() {
+  last_text_.clear();
+
+  char *clipboard_text = SDL_GetClipboardText();
+  if (clipboard_text) {
+    last_text_.assign(clipboard_text);
+    SDL_free(clipboard_text);
+  }
+
+  events_enabled_.store(true, std::memory_order_release);
+}
+
+void ClipboardController::Shutdown() {
+  events_enabled_.store(false, std::memory_order_release);
+  std::lock_guard<std::mutex> lock(pending_mutex_);
+  pending_remote_text_.reset();
+}
+
+void ClipboardController::QueueRemoteText(const char *data, size_t size) {
+  if (!events_enabled_.load(std::memory_order_acquire)) {
+    return;
+  }
+  if (!data || size == 0) {
+    return;
+  }
+  if (size > kMaxClipboardTextBytes) {
+    LOG_WARN("Ignore oversized remote clipboard text: {} bytes", size);
+    return;
+  }
+  if (std::memchr(data, '\0', size) != nullptr) {
+    LOG_WARN("Ignore remote clipboard text containing an embedded NUL byte");
+    return;
+  }
+
+  {
+    std::lock_guard<std::mutex> lock(pending_mutex_);
+    if (!events_enabled_.load(std::memory_order_relaxed)) {
+      return;
+    }
+    // Only the newest clipboard value matters. Replacing it also bounds the
+    // amount of memory a busy or malicious peer can queue.
+    pending_remote_text_ = std::string(data, size);
+  }
+
+  SDL_Event event{};
+  event.type = event_type_;
+  if (event_type_ != 0 && !SDL_PushEvent(&event)) {
+    // MainLoop also drains the pending value after its wait timeout.
+    LOG_WARN("Failed to wake SDL loop for remote clipboard text: {}",
+             SDL_GetError());
+  }
+}
+
+void ClipboardController::ApplyPendingRemoteText() {
+  if (!events_enabled_.load(std::memory_order_acquire)) {
+    return;
+  }
+
+  std::optional<std::string> pending_text;
+  {
+    std::lock_guard<std::mutex> lock(pending_mutex_);
+    pending_text.swap(pending_remote_text_);
+  }
+  if (!pending_text || *pending_text == last_text_) {
+    return;
+  }
+
+  // SDL clipboard functions must run on the thread that initialized SDL.
+  if (!SDL_SetClipboardText(pending_text->c_str())) {
+    LOG_ERROR("Failed to set remote clipboard text: {}", SDL_GetError());
+    return;
+  }
+
+  // SDL will normally emit SDL_EVENT_CLIPBOARD_UPDATE for this write. Update
+  // the baseline first so that event cannot echo the text back to the sender.
+  last_text_ = std::move(*pending_text);
+}
+
+void ClipboardController::HandleLocalUpdate() {
+  if (!events_enabled_.load(std::memory_order_acquire)) {
+    return;
+  }
+  if (!SDL_HasClipboardText()) {
+    last_text_.clear();
+    return;
+  }
+
+  char *clipboard_text = SDL_GetClipboardText();
+  if (!clipboard_text) {
+    LOG_WARN("Failed to read local clipboard text: {}", SDL_GetError());
+    return;
+  }
+
+  std::string text(clipboard_text);
+  SDL_free(clipboard_text);
+  if (text == last_text_) {
+    return;
+  }
+
+  // Record the value before sending. Duplicate SDL notifications and a
+  // remote write of the same value must not create a clipboard feedback loop.
+  last_text_ = text;
+  if (text.empty()) {
+    return;
+  }
+  if (text.size() > kMaxClipboardTextBytes) {
+    LOG_WARN("Ignore oversized local clipboard text: {} bytes", text.size());
+    return;
+  }
+
+  SendToPeers(text);
+}
+
+int ClipboardController::SendToPeers(const std::string &text) {
+  std::shared_lock lock(owner_.remote_sessions_mutex_);
+  for (const auto &[remote_id, props] : owner_.remote_sessions_) {
+    if (!props || !props->peer_ || !props->connection_established_ ||
+        !props->enable_mouse_control_) {
+      continue;
+    }
+
+    const int ret =
+        SendReliableDataFrame(props->peer_, text.data(), text.size(),
+                              props->clipboard_label_.c_str());
+    if (ret != 0) {
+      LOG_WARN("Failed to send clipboard data to peer [{}], ret={}",
+               remote_id.c_str(), ret);
+      return ret;
+    }
+  }
+
+  if (owner_.peer_) {
+    const int ret =
+        SendReliableDataFrame(owner_.peer_, text.data(), text.size(),
+                              owner_.clipboard_label_.c_str());
+    if (ret != 0) {
+      LOG_WARN("Failed to send clipboard data to peer [{}], ret={}",
+               owner_.remote_id_display_, ret);
+      return ret;
+    }
+  }
+
+  return 0;
+}
+
+} // namespace crossdesk

apps/desktop/src/gui/features/clipboard/clipboard_controller.h

@@ -0,0 +1,45 @@
+#ifndef CROSSDESK_GUI_CLIPBOARD_CONTROLLER_H_
+#define CROSSDESK_GUI_CLIPBOARD_CONTROLLER_H_
+
+#include <SDL3/SDL.h>
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <mutex>
+#include <optional>
+#include <string>
+
+namespace crossdesk {
+
+class GuiRuntime;
+
+// Owns clipboard synchronization state and keeps feedback-loop prevention out
+// of the main UI coordinator.
+class ClipboardController {
+public:
+  explicit ClipboardController(GuiRuntime &owner);
+
+  void SetEventType(uint32_t event_type);
+  uint32_t event_type() const;
+
+  void Initialize();
+  void Shutdown();
+  void QueueRemoteText(const char *data, size_t size);
+  void ApplyPendingRemoteText();
+  void HandleLocalUpdate();
+
+private:
+  int SendToPeers(const std::string &text);
+
+  GuiRuntime &owner_;
+  uint32_t event_type_ = 0;
+  std::atomic<bool> events_enabled_{false};
+  std::mutex pending_mutex_;
+  std::optional<std::string> pending_remote_text_;
+  std::string last_text_;
+};
+
+} // namespace crossdesk
+
+#endif // CROSSDESK_GUI_CLIPBOARD_CONTROLLER_H_

apps/desktop/src/gui/features/devices/session_device_manager.cpp

@@ -0,0 +1,584 @@
+#include "features/devices/session_device_manager.h"
+
+#include <remote_action.h>
+
+#include <chrono>
+#include <cstdlib>
+
+#include <display_stream_id.h>
+#include "platform.h"
+#include "rd_log.h"
+#include "runtime/gui_runtime.h"
+
+namespace crossdesk {
+namespace {
+
+constexpr uint64_t kCaptureResumeKeyFrameGapMs = 500;
+constexpr size_t kMaxCapturedKeyboardInputs = 512;
+constexpr auto kFrameDeadlineTolerance = std::chrono::milliseconds(1);
+
+} // namespace
+
+SessionDeviceManager::SessionDeviceManager(GuiRuntime &owner) : owner_(owner) {}
+
+bool SessionDeviceManager::ShouldSendCapturedFrame(
+    std::chrono::steady_clock::time_point now, int fps) {
+  const auto interval =
+      std::chrono::nanoseconds(std::chrono::seconds(1)) / (fps > 0 ? fps : 1);
+  if (next_frame_deadline_ == std::chrono::steady_clock::time_point{}) {
+    next_frame_deadline_ = now;
+  }
+  if (now + kFrameDeadlineTolerance < next_frame_deadline_) {
+    return false;
+  }
+  next_frame_deadline_ += interval;
+  if (next_frame_deadline_ <= now) {
+    next_frame_deadline_ = now + interval;
+  }
+  return true;
+}
+
+void SessionDeviceManager::Initialize() {
+  InitializeAudioOutput();
+  screen_capturer_factory_ = new ScreenCapturerFactory();
+  speaker_capturer_factory_ = new SpeakerCapturerFactory();
+  device_controller_factory_ = new DeviceControllerFactory();
+  keyboard_capturer_ =
+      static_cast<KeyboardCapturer *>(device_controller_factory_->Create(
+          DeviceControllerFactory::Device::Keyboard));
+}
+
+int SessionDeviceManager::InitializeScreenCapturer() {
+#ifdef __APPLE__
+  if (!owner_.EnsureMacScreenRecordingPermission()) {
+    return -1;
+  }
+#endif
+
+  if (!screen_capturer_) {
+    screen_capturer_ =
+        static_cast<ScreenCapturer *>(screen_capturer_factory_->Create());
+  }
+
+  last_frame_time_ = {};
+  next_frame_deadline_ = {};
+  const int fps = owner_.config_center_->GetVideoFrameRate() ==
+                          ConfigCenter::VIDEO_FRAME_RATE::FPS_30
+                      ? 30
+                      : 60;
+  LOG_INFO("Init screen capturer with {} fps", fps);
+  display_info_list_.clear();
+  registered_display_stream_count_ = 0;
+  last_video_frame_stream_id_.clear();
+  invalid_video_stream_id_logged_ = false;
+
+  const int init_ret = screen_capturer_->Init(
+      fps, [this, fps](unsigned char *data, int size, int width, int height,
+                       const char *display_name) {
+        const auto now_time = std::chrono::steady_clock::now();
+        if (!ShouldSendCapturedFrame(now_time, fps)) {
+          return;
+        }
+
+        const bool has_previous_frame =
+            last_frame_time_.time_since_epoch().count() != 0;
+        const auto duration_ms =
+            has_previous_frame
+                ? std::chrono::duration_cast<std::chrono::milliseconds>(
+                      now_time - last_frame_time_)
+                      .count()
+                : 0;
+
+        std::vector<std::string> connected_remote_ids;
+        {
+          std::shared_lock lock(owner_.connection_status_mutex_);
+          connected_remote_ids.reserve(owner_.connection_status_.size());
+          for (const auto &[remote_id, status] : owner_.connection_status_) {
+            if (status == ConnectionStatus::Connected) {
+              connected_remote_ids.push_back(remote_id);
+            }
+          }
+        }
+
+        // Capture can still deliver frames while ICE is gathering or after
+        // the final controller disconnects. Do not broadcast those frames to
+        // MiniRTC: a broadcast also reaches newly joining peers whose ICE
+        // transport is not ready yet.
+        if (connected_remote_ids.empty()) {
+          last_frame_time_ = now_time;
+          return;
+        }
+
+        const std::string stream_id = ResolveDisplayStreamId(
+            display_name, registered_display_stream_count_, -1,
+            last_video_frame_stream_id_);
+        if (stream_id.empty()) {
+          if (!invalid_video_stream_id_logged_) {
+            LOG_ERROR(
+                "Drop captured frames with an empty or unregistered video "
+                "stream id, reported='{}', registered_streams={}",
+                display_name ? display_name : "",
+                registered_display_stream_count_);
+            invalid_video_stream_id_logged_ = true;
+          }
+          return;
+        }
+        invalid_video_stream_id_logged_ = false;
+        const bool resumed_after_gap =
+            has_previous_frame && duration_ms >= kCaptureResumeKeyFrameGapMs;
+        const bool stream_changed = !last_video_frame_stream_id_.empty() &&
+                                    last_video_frame_stream_id_ != stream_id;
+        if (resumed_after_gap || stream_changed) {
+          if (RequestVideoKeyFrame(owner_.peer_, stream_id.c_str()) == 0) {
+            LOG_INFO("Request video key frame before sending captured frame, "
+                     "stream='{}', gap_ms={}, stream_changed={}",
+                     stream_id, duration_ms, stream_changed);
+          }
+        }
+
+        XVideoFrame frame{};
+        frame.data = reinterpret_cast<const char *>(data);
+        frame.size = size;
+        frame.width = width;
+        frame.height = height;
+        frame.captured_timestamp = GetSystemTimeMicros(owner_.peer_);
+        for (const std::string &remote_id : connected_remote_ids) {
+          SendVideoFrameToPeer(owner_.peer_, &frame, stream_id.c_str(),
+                               remote_id.data(), remote_id.size());
+        }
+        last_video_frame_stream_id_ = stream_id;
+        last_frame_time_ = now_time;
+      });
+
+  if (init_ret == 0) {
+    LOG_INFO("Init screen capturer success");
+    const auto latest_display_info = screen_capturer_->GetDisplayInfoList();
+    if (!latest_display_info.empty()) {
+      display_info_list_ = latest_display_info;
+    }
+    registered_display_stream_count_ = display_info_list_.size();
+    return 0;
+  }
+
+  LOG_ERROR("Init screen capturer failed");
+  screen_capturer_->Destroy();
+  delete screen_capturer_;
+  screen_capturer_ = nullptr;
+  return -1;
+}
+
+int SessionDeviceManager::StartScreenCapturer() {
+#ifdef __APPLE__
+  if (!owner_.EnsureMacScreenRecordingPermission()) {
+    return -1;
+  }
+#endif
+
+  if (!screen_capturer_) {
+    LOG_INFO("Screen capturer instance missing, recreating before start");
+    if (InitializeScreenCapturer() != 0) {
+      LOG_ERROR("Recreate screen capturer failed");
+      return -1;
+    }
+  }
+
+  LOG_INFO("Start screen capturer, show cursor: {}", owner_.show_cursor_);
+  const int ret = screen_capturer_->Start(owner_.show_cursor_);
+  if (ret != 0) {
+    LOG_ERROR("Start screen capturer failed: {}", ret);
+  }
+  return ret;
+}
+
+int SessionDeviceManager::StopScreenCapturer() {
+  if (screen_capturer_) {
+    LOG_INFO("Stop screen capturer");
+    screen_capturer_->Stop();
+  }
+  return 0;
+}
+
+int SessionDeviceManager::StartSpeakerCapturer() {
+  if (!speaker_capturer_) {
+    speaker_capturer_ =
+        static_cast<SpeakerCapturer *>(speaker_capturer_factory_->Create());
+    const int init_ret = speaker_capturer_->Init(
+        [this](unsigned char *data, size_t size, const char *audio_name) {
+          SendAudioFrame(owner_.peer_, reinterpret_cast<const char *>(data),
+                         size, owner_.audio_label_.c_str());
+        });
+
+    if (init_ret != 0) {
+      speaker_capturer_->Destroy();
+      delete speaker_capturer_;
+      speaker_capturer_ = nullptr;
+    }
+  }
+
+  if (!speaker_capturer_) {
+    return -1;
+  }
+
+  const int ret = speaker_capturer_->Start();
+  if (ret != 0) {
+    LOG_ERROR("Start speaker capturer failed: {}", ret);
+    return ret;
+  }
+  owner_.start_speaker_capturer_ = true;
+  return 0;
+}
+
+int SessionDeviceManager::StopSpeakerCapturer() {
+  if (speaker_capturer_) {
+    speaker_capturer_->Stop();
+    owner_.start_speaker_capturer_ = false;
+  }
+  return 0;
+}
+
+int SessionDeviceManager::StartMouseController() {
+#ifdef __APPLE__
+  if (!owner_.EnsureMacAccessibilityPermission()) {
+    return -1;
+  }
+#endif
+
+  if (!device_controller_factory_) {
+    LOG_INFO("Device controller factory is nullptr");
+    return -1;
+  }
+
+#if defined(__linux__) && !defined(__APPLE__)
+  if (IsWaylandSession()) {
+    if (!screen_capturer_) {
+      return 1;
+    }
+    const auto latest_display_info = screen_capturer_->GetDisplayInfoList();
+    if (latest_display_info.empty() ||
+        latest_display_info[0].handle == nullptr) {
+      return 1;
+    }
+  }
+
+  if (screen_capturer_) {
+    const auto latest_display_info = screen_capturer_->GetDisplayInfoList();
+    if (!latest_display_info.empty()) {
+      display_info_list_ = latest_display_info;
+    }
+  }
+#endif
+
+  mouse_controller_ =
+      static_cast<MouseController *>(device_controller_factory_->Create(
+          DeviceControllerFactory::Device::Mouse));
+  if (!mouse_controller_) {
+    LOG_ERROR("Create mouse controller failed");
+    return -1;
+  }
+
+  const int init_ret = mouse_controller_->Init(display_info_list_);
+  if (init_ret != 0) {
+    LOG_INFO("Destroy mouse controller");
+    mouse_controller_->Destroy();
+    delete mouse_controller_;
+    mouse_controller_ = nullptr;
+  }
+  return init_ret;
+}
+
+int SessionDeviceManager::StopMouseController() {
+  if (mouse_controller_) {
+    mouse_controller_->Destroy();
+    delete mouse_controller_;
+    mouse_controller_ = nullptr;
+  }
+  return 0;
+}
+
+int SessionDeviceManager::StartKeyboardCapturer() {
+  owner_.keyboard_capturer_uses_window_events_ = false;
+
+#ifdef __APPLE__
+  if (!owner_.EnsureMacAccessibilityPermission()) {
+    owner_.keyboard_capturer_uses_window_events_ = true;
+    return 0;
+  }
+#endif
+
+#if defined(__linux__) && !defined(__APPLE__)
+  if (IsWaylandSession()) {
+    owner_.keyboard_capturer_uses_window_events_ = true;
+    LOG_INFO("Start keyboard capturer with Slint Wayland backend");
+    return 0;
+  }
+#endif
+
+  if (!keyboard_capturer_) {
+    owner_.keyboard_capturer_uses_window_events_ = true;
+    LOG_WARN(
+        "keyboard capturer is nullptr, falling back to Slint keyboard events");
+    return 0;
+  }
+
+  const int hook_ret = keyboard_capturer_->Hook(
+      [](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,
+                                              extended);
+        }
+      },
+      this);
+  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");
+  }
+  return 0;
+}
+
+int SessionDeviceManager::StopKeyboardCapturer() {
+  if (owner_.keyboard_capturer_uses_window_events_) {
+    owner_.keyboard_capturer_uses_window_events_ = false;
+    LOG_INFO("Stop keyboard capturer with Slint keyboard backend");
+    return 0;
+  }
+
+  if (keyboard_capturer_) {
+    keyboard_capturer_->Unhook();
+    ClearCapturedKeyboardInput();
+    LOG_INFO("Stop keyboard capturer");
+  }
+  return 0;
+}
+
+int SessionDeviceManager::InitializeAudioOutput() {
+  SDL_AudioSpec desired_out{};
+  desired_out.freq = 48000;
+  desired_out.format = SDL_AUDIO_S16;
+  desired_out.channels = 1;
+
+  auto open_stream = [&]() {
+    output_stream_ = SDL_OpenAudioDeviceStream(
+        SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &desired_out, nullptr, nullptr);
+    return output_stream_ != nullptr;
+  };
+
+  if (!open_stream()) {
+#if defined(__linux__) && !defined(__APPLE__)
+    LOG_WARN("Failed to open output stream with driver [{}]: {}",
+             getenv("SDL_AUDIODRIVER") ? getenv("SDL_AUDIODRIVER")
+                                       : "(default)",
+             SDL_GetError());
+
+    setenv("SDL_AUDIODRIVER", "dummy", 1);
+    SDL_QuitSubSystem(SDL_INIT_AUDIO);
+    if (!SDL_InitSubSystem(SDL_INIT_AUDIO)) {
+      LOG_ERROR("Failed to reinitialize SDL audio with dummy driver: {}",
+                SDL_GetError());
+      return -1;
+    }
+    if (!open_stream()) {
+      LOG_ERROR("Failed to open output stream with dummy driver: {}",
+                SDL_GetError());
+      return -1;
+    }
+    LOG_WARN("Audio output disabled, using SDL dummy audio driver");
+#else
+    LOG_ERROR("Failed to open output stream: {}", SDL_GetError());
+    return -1;
+#endif
+  }
+
+  SDL_ResumeAudioDevice(SDL_GetAudioStreamDevice(output_stream_));
+  return 0;
+}
+
+int SessionDeviceManager::DestroyAudioOutput() {
+  if (output_stream_) {
+    SDL_CloseAudioDevice(SDL_GetAudioStreamDevice(output_stream_));
+    SDL_DestroyAudioStream(output_stream_);
+    output_stream_ = nullptr;
+  }
+  return 0;
+}
+
+void SessionDeviceManager::PushAudio(const char *data, size_t size) {
+  if (!output_stream_) {
+    return;
+  }
+  const int pushed = SDL_PutAudioStreamData(
+      output_stream_, reinterpret_cast<const Uint8 *>(data),
+      static_cast<int>(size));
+  if (pushed < 0) {
+    LOG_ERROR("Failed to push audio data: {}", SDL_GetError());
+  }
+}
+
+void SessionDeviceManager::UpdateInteractions() {
+#if defined(__linux__) && !defined(__APPLE__)
+  const bool is_wayland_session = IsWaylandSession();
+  const bool stop_wayland_mouse_before_screen =
+      is_wayland_session && !owner_.start_screen_capturer_ &&
+      owner_.screen_capturer_is_started_ && !owner_.start_mouse_controller_ &&
+      owner_.mouse_controller_is_started_;
+  if (stop_wayland_mouse_before_screen) {
+    LOG_INFO("Stopping Wayland mouse controller before screen capturer to "
+             "cleanly release the shared portal session");
+    StopMouseController();
+    owner_.mouse_controller_is_started_ = false;
+  }
+#endif
+
+  if (owner_.start_screen_capturer_ && !owner_.screen_capturer_is_started_) {
+    if (StartScreenCapturer() == 0) {
+      owner_.screen_capturer_is_started_ = true;
+    }
+  } else if (!owner_.start_screen_capturer_ &&
+             owner_.screen_capturer_is_started_) {
+    StopScreenCapturer();
+    owner_.screen_capturer_is_started_ = false;
+  }
+
+  if (owner_.start_speaker_capturer_ && !owner_.speaker_capturer_is_started_) {
+    if (StartSpeakerCapturer() == 0) {
+      owner_.speaker_capturer_is_started_ = true;
+    }
+  } else if (!owner_.start_speaker_capturer_ &&
+             owner_.speaker_capturer_is_started_) {
+    StopSpeakerCapturer();
+    owner_.speaker_capturer_is_started_ = false;
+  }
+
+  if (owner_.start_mouse_controller_ && !owner_.mouse_controller_is_started_) {
+    if (StartMouseController() == 0) {
+      owner_.mouse_controller_is_started_ = true;
+    }
+  } else if (!owner_.start_mouse_controller_ &&
+             owner_.mouse_controller_is_started_) {
+    StopMouseController();
+    owner_.mouse_controller_is_started_ = false;
+  }
+
+#if defined(__linux__) || defined(__APPLE__)
+  if (owner_.screen_capturer_is_started_ && screen_capturer_ &&
+      mouse_controller_) {
+    const auto latest_display_info = screen_capturer_->GetDisplayInfoList();
+    if (!latest_display_info.empty()) {
+      display_info_list_ = latest_display_info;
+      mouse_controller_->UpdateDisplayInfoList(display_info_list_);
+    }
+  }
+#endif
+
+  if (owner_.start_keyboard_capturer_ && owner_.focus_on_stream_window_) {
+    if (!owner_.keyboard_capturer_is_started_ && StartKeyboardCapturer() == 0) {
+      owner_.keyboard_capturer_is_started_ = true;
+    }
+    if (owner_.keyboard_capturer_is_started_) {
+      DrainCapturedKeyboardInput();
+      owner_.keyboard_.SendHeartbeat(false);
+    }
+  } else if (owner_.keyboard_capturer_is_started_) {
+    owner_.keyboard_.ForceReleasePressedKeys();
+    StopKeyboardCapturer();
+    owner_.keyboard_capturer_is_started_ = false;
+  }
+
+  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) {
+  return keyboard_capturer_ && keyboard_capturer_->SendKeyboardCommand(
+                                   key_code, is_down, scan_code, extended) == 0;
+}
+
+void SessionDeviceManager::SendMouseCommand(const RemoteAction &action,
+                                            int selected_display) {
+  if (mouse_controller_) {
+    mouse_controller_->SendMouseCommand(action, selected_display);
+  }
+}
+
+int SessionDeviceManager::SwitchDisplay(int display_id) {
+  return screen_capturer_ ? screen_capturer_->SwitchTo(display_id) : -1;
+}
+
+void SessionDeviceManager::ResetToInitialDisplay() {
+  if (screen_capturer_) {
+    screen_capturer_->ResetToInitialMonitor();
+  }
+}
+
+const std::vector<DisplayInfo> &
+SessionDeviceManager::display_info_list() const {
+  return display_info_list_;
+}
+
+void SessionDeviceManager::DestroyDevices() {
+  if (mouse_controller_) {
+    mouse_controller_->Destroy();
+    delete mouse_controller_;
+    mouse_controller_ = nullptr;
+  }
+  if (screen_capturer_) {
+    screen_capturer_->Destroy();
+    delete screen_capturer_;
+    screen_capturer_ = nullptr;
+  }
+  if (speaker_capturer_) {
+    speaker_capturer_->Destroy();
+    delete speaker_capturer_;
+    speaker_capturer_ = nullptr;
+  }
+  if (keyboard_capturer_) {
+    delete keyboard_capturer_;
+    keyboard_capturer_ = nullptr;
+  }
+}
+
+void SessionDeviceManager::DestroyFactories() {
+  delete screen_capturer_factory_;
+  screen_capturer_factory_ = nullptr;
+  delete speaker_capturer_factory_;
+  speaker_capturer_factory_ = nullptr;
+  delete device_controller_factory_;
+  device_controller_factory_ = nullptr;
+}
+
+} // namespace crossdesk

apps/desktop/src/gui/features/devices/session_device_manager.h

@@ -0,0 +1,96 @@
+#ifndef CROSSDESK_GUI_SESSION_DEVICE_MANAGER_H_
+#define CROSSDESK_GUI_SESSION_DEVICE_MANAGER_H_
+
+#include <SDL3/SDL.h>
+
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <deque>
+#include <mutex>
+#include <string>
+#include <vector>
+
+#include <remote_action.h>
+
+#include "device_controller.h"
+#include "device_controller_factory.h"
+#include "display_info.h"
+#include "screen_capturer_factory.h"
+#include "speaker_capturer_factory.h"
+
+namespace crossdesk {
+
+class GuiRuntime;
+
+// Owns media capture/playback and remote input devices for the active GUI
+// session. GuiRuntime supplies application intent; this class handles device
+// creation, updates and teardown.
+class SessionDeviceManager {
+public:
+  explicit SessionDeviceManager(GuiRuntime &owner);
+
+  void Initialize();
+  void UpdateInteractions();
+  void DestroyDevices();
+  void DestroyFactories();
+
+  int InitializeScreenCapturer();
+  int StartScreenCapturer();
+  int StopScreenCapturer();
+  int StartSpeakerCapturer();
+  int StopSpeakerCapturer();
+  int StartMouseController();
+  int StopMouseController();
+  int StartKeyboardCapturer();
+  int StopKeyboardCapturer();
+
+  int InitializeAudioOutput();
+  int DestroyAudioOutput();
+  void PushAudio(const char *data, size_t size);
+
+  bool SendKeyboardCommand(int key_code, bool is_down, uint32_t scan_code,
+                           bool extended);
+  void SendMouseCommand(const RemoteAction &action, int selected_display);
+  int SwitchDisplay(int display_id);
+  void ResetToInitialDisplay();
+
+  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();
+  bool ShouldSendCapturedFrame(std::chrono::steady_clock::time_point now,
+                               int fps);
+
+  GuiRuntime &owner_;
+  SDL_AudioStream *output_stream_ = nullptr;
+  ScreenCapturerFactory *screen_capturer_factory_ = nullptr;
+  ScreenCapturer *screen_capturer_ = nullptr;
+  SpeakerCapturerFactory *speaker_capturer_factory_ = nullptr;
+  SpeakerCapturer *speaker_capturer_ = nullptr;
+  DeviceControllerFactory *device_controller_factory_ = nullptr;
+  MouseController *mouse_controller_ = nullptr;
+  KeyboardCapturer *keyboard_capturer_ = nullptr;
+  std::vector<DisplayInfo> display_info_list_;
+  size_t registered_display_stream_count_ = 0;
+  std::deque<CapturedKeyboardInput> captured_keyboard_inputs_;
+  std::mutex captured_keyboard_inputs_mutex_;
+  std::chrono::steady_clock::time_point last_frame_time_{};
+  std::chrono::steady_clock::time_point next_frame_deadline_{};
+  std::string last_video_frame_stream_id_;
+  bool invalid_video_stream_id_logged_ = false;
+};
+
+} // namespace crossdesk
+
+#endif // CROSSDESK_GUI_SESSION_DEVICE_MANAGER_H_

apps/desktop/src/gui/features/file_transfer/file_transfer_manager.cpp

@@ -0,0 +1,340 @@
+#include "features/file_transfer/file_transfer_manager.h"
+
+#include <algorithm>
+#include <chrono>
+#include <filesystem>
+#include <limits>
+#include <memory>
+#include <mutex>
+#include <shared_mutex>
+#include <string>
+#include <thread>
+#include <utility>
+
+#include "file_transfer.h"
+#include "filesystem_utf8.h"
+#include "rd_log.h"
+#include "runtime/gui_runtime.h"
+
+namespace crossdesk {
+
+FileTransferManager::FileTransferManager(GuiRuntime &owner) : owner_(owner) {}
+
+FileTransferManager::FileTransferState &FileTransferManager::global_state() {
+  return global_state_;
+}
+
+FileTransferManager::FileTransferState &FileTransferManager::state_for(
+    const std::shared_ptr<RemoteSession> &props) {
+  return props ? props->file_transfer_ : global_state_;
+}
+
+void FileTransferManager::ProcessSelectedFile(
+    const std::string &path,
+    const std::shared_ptr<RemoteSession> &props,
+    const std::string &file_label, const std::string &remote_id) {
+  if (path.empty()) {
+    return;
+  }
+
+  FileTransferState &state = state_for(props);
+  LOG_INFO("Selected file: {}", path.c_str());
+
+  const std::filesystem::path file_path = PathFromUtf8(path);
+  std::error_code ec;
+  if (!std::filesystem::is_regular_file(file_path, ec)) {
+    LOG_ERROR("Selected path is not a regular file: {}", path);
+    return;
+  }
+  const uint64_t file_size = std::filesystem::file_size(file_path, ec);
+  if (ec) {
+    LOG_ERROR("Failed to get file size: {}", ec.message());
+    return;
+  }
+
+  {
+    std::lock_guard<std::mutex> lock(state.file_transfer_list_mutex_);
+    FileTransferState::FileTransferInfo info;
+    const auto utf8_name = file_path.filename().u8string();
+    info.file_name.assign(reinterpret_cast<const char *>(utf8_name.data()),
+                          utf8_name.size());
+    info.file_path = file_path;
+    info.file_size = file_size;
+    info.status = FileTransferState::FileTransferStatus::Queued;
+    state.file_transfer_list_.push_back(std::move(info));
+  }
+  state.file_transfer_window_visible_ = true;
+
+  auto enqueue = [&]() {
+    size_t queue_size = 0;
+    {
+      std::lock_guard<std::mutex> lock(state.file_queue_mutex_);
+      state.file_send_queue_.push(
+          FileTransferState::QueuedFile{file_path, file_label, remote_id});
+      queue_size = state.file_send_queue_.size();
+    }
+    LOG_INFO("File added to queue: {} ({} files in queue)",
+             file_path.filename().string().c_str(), queue_size);
+  };
+
+  if (state.file_sending_.load()) {
+    enqueue();
+    return;
+  }
+
+  Start(props, file_path, file_label, remote_id);
+  if (!state.file_sending_.load()) {
+    enqueue();
+  }
+}
+
+void FileTransferManager::Start(
+    std::shared_ptr<RemoteSession> props,
+    const std::filesystem::path &file_path, const std::string &file_label,
+    const std::string &remote_id) {
+  const bool is_global = !props;
+  PeerPtr *peer = is_global ? owner_.peer_ : props->peer_;
+  if (!peer) {
+    LOG_ERROR("StartFileTransfer: invalid peer");
+    return;
+  }
+
+  FileTransferState &initial_state = state_for(props);
+  bool expected = false;
+  if (!initial_state.file_sending_.compare_exchange_strong(expected, true)) {
+    LOG_WARN("StartFileTransfer called while another file is active: {}",
+             file_path.filename().string().c_str());
+    return;
+  }
+
+  const auto props_weak = std::weak_ptr<RemoteSession>(props);
+  std::thread([this, peer, file_path, file_label, props_weak, remote_id,
+               is_global]() {
+    auto props_locked = props_weak.lock();
+    FileTransferState *state = nullptr;
+    if (props_locked) {
+      state = &props_locked->file_transfer_;
+    } else if (is_global) {
+      state = &global_state_;
+    } else {
+      return;
+    }
+
+    std::error_code ec;
+    const uint64_t total_size = std::filesystem::file_size(file_path, ec);
+    if (ec) {
+      LOG_ERROR("Failed to get file size: {}", ec.message().c_str());
+      state->file_sending_ = false;
+      return;
+    }
+
+    state->file_sent_bytes_ = 0;
+    state->file_total_bytes_ = total_size;
+    state->file_send_rate_bps_ = 0;
+    state->file_transfer_window_visible_ = true;
+    {
+      std::lock_guard<std::mutex> lock(state->file_transfer_mutex_);
+      state->file_send_start_time_ = std::chrono::steady_clock::now();
+      state->file_send_last_update_time_ = state->file_send_start_time_;
+      state->file_send_last_bytes_ = 0;
+    }
+
+    FileSender sender;
+    const uint32_t file_id = FileSender::NextFileId();
+    if (props_locked) {
+      std::lock_guard<std::shared_mutex> lock(file_id_to_props_mutex_);
+      file_id_to_props_[file_id] = props_weak;
+    } else {
+      std::lock_guard<std::shared_mutex> lock(file_id_to_state_mutex_);
+      file_id_to_state_[file_id] = state;
+    }
+    state->current_file_id_ = file_id;
+
+    {
+      std::lock_guard<std::mutex> lock(state->file_transfer_list_mutex_);
+      for (auto &info : state->file_transfer_list_) {
+        if (info.file_path == file_path &&
+            info.status == FileTransferState::FileTransferStatus::Queued) {
+          info.status = FileTransferState::FileTransferStatus::Sending;
+          info.file_id = file_id;
+          info.file_size = total_size;
+          info.sent_bytes = 0;
+          break;
+        }
+      }
+    }
+
+    const int ret = sender.SendFile(
+        file_path, file_path.filename().string(),
+        [peer, file_label, remote_id](const char *buffer, size_t size) {
+          if (remote_id.empty()) {
+            return SendReliableDataFrame(peer, buffer, size,
+                                         file_label.c_str());
+          }
+          return SendReliableDataFrameToPeer(
+              peer, buffer, size, file_label.c_str(), remote_id.c_str(),
+              remote_id.size());
+        },
+        64 * 1024, file_id);
+
+    if (ret == 0) {
+      return;
+    }
+
+    state->file_sending_ = false;
+    state->file_transfer_window_visible_ = false;
+    state->file_sent_bytes_ = 0;
+    state->file_total_bytes_ = 0;
+    state->file_send_rate_bps_ = 0;
+    state->current_file_id_ = 0;
+    Unregister(file_id, props_locked != nullptr);
+
+    {
+      std::lock_guard<std::mutex> lock(state->file_transfer_list_mutex_);
+      for (auto &info : state->file_transfer_list_) {
+        if (info.file_id == file_id) {
+          info.status = FileTransferState::FileTransferStatus::Failed;
+          break;
+        }
+      }
+    }
+    LOG_ERROR("FileSender::SendFile failed for [{}], ret={}",
+              file_path.string().c_str(), ret);
+    ProcessQueue(props_locked);
+  }).detach();
+}
+
+void FileTransferManager::ProcessQueue(
+    std::shared_ptr<RemoteSession> props) {
+  FileTransferState &state = state_for(props);
+  if (state.file_sending_.load()) {
+    return;
+  }
+
+  FileTransferState::QueuedFile queued_file;
+  {
+    std::lock_guard<std::mutex> lock(state.file_queue_mutex_);
+    if (state.file_send_queue_.empty()) {
+      return;
+    }
+    queued_file = state.file_send_queue_.front();
+    state.file_send_queue_.pop();
+  }
+  Start(props, queued_file.file_path, queued_file.file_label,
+        queued_file.remote_id);
+}
+
+void FileTransferManager::Unregister(uint32_t file_id, bool per_peer) {
+  if (per_peer) {
+    std::lock_guard<std::shared_mutex> lock(file_id_to_props_mutex_);
+    file_id_to_props_.erase(file_id);
+  } else {
+    std::lock_guard<std::shared_mutex> lock(file_id_to_state_mutex_);
+    file_id_to_state_.erase(file_id);
+  }
+}
+
+void FileTransferManager::HandleAck(const char *data, size_t size) {
+  FileTransferAck ack{};
+  if (!DecodeFileTransferAck(data, size, &ack)) {
+    LOG_ERROR("FileTransferAck: invalid payload, size={}", size);
+    return;
+  }
+
+  std::shared_ptr<RemoteSession> props;
+  {
+    std::shared_lock lock(file_id_to_props_mutex_);
+    const auto it = file_id_to_props_.find(ack.file_id);
+    if (it != file_id_to_props_.end()) {
+      props = it->second.lock();
+    }
+  }
+
+  FileTransferState *state = props ? &props->file_transfer_ : nullptr;
+  if (!state) {
+    std::shared_lock lock(file_id_to_state_mutex_);
+    const auto it = file_id_to_state_.find(ack.file_id);
+    if (it != file_id_to_state_.end()) {
+      state = it->second;
+    }
+  }
+  if (!state) {
+    LOG_WARN("FileTransferAck: no state found for file_id={}", ack.file_id);
+    return;
+  }
+
+  state->file_sent_bytes_ = ack.acked_offset;
+  state->file_total_bytes_ = ack.total_size;
+  uint32_t rate_bps = 0;
+  if (props) {
+    const uint32_t bitrate =
+        props->net_traffic_stats_.data_outbound_stats.bitrate;
+    if (bitrate > 0 && state->file_sending_.load()) {
+      rate_bps = static_cast<uint32_t>(bitrate * 0.99f);
+      const uint32_t current_rate = state->file_send_rate_bps_.load();
+      if (current_rate > 0) {
+        rate_bps = static_cast<uint32_t>(current_rate * 0.7 + rate_bps * 0.3);
+      }
+    } else {
+      rate_bps = state->file_send_rate_bps_.load();
+    }
+  } else {
+    const uint32_t current_rate = state->file_send_rate_bps_.load();
+    uint32_t estimated_rate = 0;
+    const auto now = std::chrono::steady_clock::now();
+    uint64_t last_bytes = 0;
+    std::chrono::steady_clock::time_point last_time;
+    {
+      std::lock_guard<std::mutex> lock(state->file_transfer_mutex_);
+      last_bytes = state->file_send_last_bytes_;
+      last_time = state->file_send_last_update_time_;
+    }
+    if (state->file_sending_.load() && ack.acked_offset >= last_bytes) {
+      const auto delta_bytes = ack.acked_offset - last_bytes;
+      const double seconds =
+          std::chrono::duration<double>(now - last_time).count();
+      if (seconds > 0.0 && delta_bytes > 0) {
+        const double bits_per_second = delta_bytes * 8.0 / seconds;
+        estimated_rate = static_cast<uint32_t>((std::min)(
+            bits_per_second,
+            static_cast<double>((std::numeric_limits<uint32_t>::max)())));
+      }
+    }
+    rate_bps =
+        estimated_rate > 0 && current_rate > 0
+            ? static_cast<uint32_t>(current_rate * 0.7 + estimated_rate * 0.3)
+        : estimated_rate > 0 ? estimated_rate
+                             : current_rate;
+  }
+
+  state->file_send_rate_bps_ = rate_bps;
+  state->file_send_last_bytes_ = ack.acked_offset;
+  state->file_send_last_update_time_ = std::chrono::steady_clock::now();
+  {
+    std::lock_guard<std::mutex> lock(state->file_transfer_list_mutex_);
+    for (auto &info : state->file_transfer_list_) {
+      if (info.file_id == ack.file_id) {
+        info.sent_bytes = ack.acked_offset;
+        info.file_size = ack.total_size;
+        info.rate_bps = rate_bps;
+        if ((ack.flags & 0x01) != 0) {
+          info.status = FileTransferState::FileTransferStatus::Completed;
+          info.sent_bytes = ack.total_size;
+        }
+        break;
+      }
+    }
+  }
+
+  if ((ack.flags & 0x01) == 0) {
+    return;
+  }
+  LOG_INFO("File transfer completed: file_id={}, bytes={}", ack.file_id,
+           ack.total_size);
+  state->file_transfer_window_visible_ = true;
+  state->file_sending_ = false;
+  Unregister(ack.file_id, props != nullptr);
+  ProcessQueue(props);
+}
+
+} // namespace crossdesk

apps/desktop/src/gui/features/file_transfer/file_transfer_manager.h

@@ -0,0 +1,54 @@
+#ifndef CROSSDESK_GUI_FILE_TRANSFER_MANAGER_H_
+#define CROSSDESK_GUI_FILE_TRANSFER_MANAGER_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+#include <shared_mutex>
+#include <string>
+#include <unordered_map>
+
+#include "runtime/gui_state.h"
+
+namespace crossdesk {
+
+class GuiRuntime;
+
+class FileTransferManager {
+public:
+  using FileTransferState = gui_detail::FileTransferState;
+  using RemoteSession = gui_detail::RemoteSession;
+
+  explicit FileTransferManager(GuiRuntime &owner);
+
+  FileTransferState &global_state();
+  FileTransferState &
+  state_for(const std::shared_ptr<RemoteSession> &props);
+
+  void
+  ProcessSelectedFile(const std::string &path,
+                      const std::shared_ptr<RemoteSession> &props,
+                      const std::string &file_label,
+                      const std::string &remote_id = "");
+  void HandleAck(const char *data, size_t size);
+
+private:
+  void Start(std::shared_ptr<RemoteSession> props,
+             const std::filesystem::path &file_path,
+             const std::string &file_label, const std::string &remote_id = "");
+  void ProcessQueue(std::shared_ptr<RemoteSession> props);
+  void Unregister(uint32_t file_id, bool per_peer);
+
+  GuiRuntime &owner_;
+  FileTransferState global_state_;
+  std::unordered_map<uint32_t, std::weak_ptr<RemoteSession>>
+      file_id_to_props_;
+  std::shared_mutex file_id_to_props_mutex_;
+  std::unordered_map<uint32_t, FileTransferState *> file_id_to_state_;
+  std::shared_mutex file_id_to_state_mutex_;
+};
+
+} // namespace crossdesk
+
+#endif // CROSSDESK_GUI_FILE_TRANSFER_MANAGER_H_

apps/desktop/src/gui/features/input/keyboard_controller.cpp

@@ -0,0 +1,365 @@
+#include "features/input/keyboard_controller.h"
+
+#include <remote_action.h>
+
+#include <SDL3/SDL.h>
+
+#include <cstdint>
+#include <mutex>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "minirtc.h"
+#include "rd_log.h"
+#include "runtime/gui_runtime.h"
+#include "windows_key_metadata.h"
+#if _WIN32
+#include "interactive_state.h"
+#include "service_host.h"
+#endif
+
+namespace crossdesk {
+namespace {
+
+constexpr uint32_t kHeartbeatIntervalMs = 500;
+constexpr uint32_t kRemoteReleaseTimeoutMs = 2500;
+
+int NormalizeWindowsModifierVk(int key_code, uint32_t scan_code,
+                               bool extended) {
+#if _WIN32
+  if (key_code != 0x10 && key_code != 0x11 && key_code != 0x12) {
+    return key_code;
+  }
+
+  UINT scan_code_with_prefix = static_cast<UINT>(scan_code & 0xFF);
+  if (extended) {
+    scan_code_with_prefix |= 0xE000;
+  }
+  const UINT normalized_vk =
+      MapVirtualKeyW(scan_code_with_prefix, MAPVK_VSC_TO_VK_EX);
+  return normalized_vk != 0 ? static_cast<int>(normalized_vk) : key_code;
+#else
+  (void)scan_code;
+  (void)extended;
+  return key_code;
+#endif
+}
+
+void PopulateWindowsKeyMetadataFromVk(int key_code, uint32_t* scan_code_out,
+                                      bool* extended_out) {
+  if (!scan_code_out || !extended_out) {
+    return;
+  }
+#if _WIN32
+  const UINT scan_code =
+      MapVirtualKeyW(static_cast<UINT>(key_code), MAPVK_VK_TO_VSC_EX);
+  if (scan_code != 0) {
+    *scan_code_out = static_cast<uint32_t>(scan_code & 0xFF);
+    *extended_out = (scan_code & 0xFF00) != 0;
+    return;
+  }
+#endif
+  LookupWindowsKeyMetadataFromVk(key_code, scan_code_out, extended_out);
+}
+
+#if _WIN32
+constexpr uint32_t kSecureDesktopInputLogIntervalMs = 2000;
+
+void LogSecureDesktopInputBlocked(uint32_t* last_tick, const char* stage) {
+  const uint32_t now = static_cast<uint32_t>(SDL_GetTicks());
+  if (*last_tick != 0 && now - *last_tick < kSecureDesktopInputLogIntervalMs) {
+    return;
+  }
+  *last_tick = now;
+  LOG_WARN(
+      "local secure-desktop input blocked, stage={}, normal SendInput path "
+      "cannot drive the Windows password UI",
+      stage ? stage : "");
+}
+
+bool IsTransientSecureDesktopInputFailure(const nlohmann::json& response,
+                                          const RemoteAction& action) {
+  return response.is_object() &&
+         response.value("error", std::string()) == "send_input_failed" &&
+         response.value("code", 0u) == ERROR_ACCESS_DENIED &&
+         action.type == ControlType::keyboard &&
+         action.k.flag == KeyFlag::key_up;
+}
+#endif
+
+}  // namespace
+
+KeyboardController::KeyboardController(GuiRuntime& owner) : owner_(owner) {}
+
+void KeyboardController::TrackPressedKey(int key_code, bool is_down,
+                                         uint32_t scan_code, bool extended) {
+  std::lock_guard<std::mutex> lock(pressed_keys_mutex_);
+  if (is_down) {
+    pressed_keys_[key_code] = PressedKey{key_code, scan_code, extended};
+  } else {
+    pressed_keys_.erase(key_code);
+  }
+}
+
+void KeyboardController::ForceReleasePressedKeys() {
+  std::vector<PressedKey> pressed_keys;
+  {
+    std::lock_guard<std::mutex> lock(pressed_keys_mutex_);
+    pressed_keys.reserve(pressed_keys_.size());
+    for (const auto& [_, key] : pressed_keys_) {
+      pressed_keys.push_back(key);
+    }
+    pressed_keys_.clear();
+  }
+
+  for (const PressedKey& key : pressed_keys) {
+    SendKeyCommand(key.key_code, false, key.scan_code, key.extended);
+  }
+  SendHeartbeat(true);
+}
+
+void KeyboardController::SendHeartbeat(bool force) {
+  const uint32_t now = static_cast<uint32_t>(SDL_GetTicks());
+  if (!force && now - last_heartbeat_tick_ < kHeartbeatIntervalMs) {
+    return;
+  }
+
+  RemoteAction action{};
+  action.type = ControlType::keyboard_state;
+  action.ks.seq = ++state_sequence_;
+  {
+    std::lock_guard<std::mutex> lock(pressed_keys_mutex_);
+    size_t index = 0;
+    for (const auto& [_, key] : pressed_keys_) {
+      if (index >= kMaxKeyboardStateKeys) {
+        LOG_WARN("Keyboard heartbeat truncated, pressed_keys={}",
+                 pressed_keys_.size());
+        break;
+      }
+      action.ks.pressed_keys[index].key_value =
+          static_cast<size_t>(key.key_code);
+      action.ks.pressed_keys[index].scan_code = key.scan_code;
+      action.ks.pressed_keys[index].extended = key.extended;
+      ++index;
+    }
+    action.ks.pressed_count = index;
+  }
+
+  const std::string target_id = owner_.controlled_remote_id_.empty()
+                                    ? owner_.focused_remote_id_
+                                    : owner_.controlled_remote_id_;
+  const auto props_it = owner_.remote_sessions_.find(target_id);
+  if (target_id.empty() || props_it == owner_.remote_sessions_.end() ||
+      props_it->second->connection_status_.load() !=
+          ConnectionStatus::Connected ||
+      !props_it->second->peer_) {
+    last_heartbeat_tick_ = now;
+    return;
+  }
+
+  const std::string message = action.to_json();
+  const int result = SendReliableDataFrame(
+      props_it->second->peer_, message.c_str(), message.size(),
+      props_it->second->keyboard_label_.c_str());
+  if (result != 0) {
+    LOG_WARN("Send keyboard heartbeat failed, remote_id={}, ret={}", target_id,
+             result);
+  }
+  last_heartbeat_tick_ = now;
+}
+
+int KeyboardController::SendKeyCommand(int key_code, bool is_down,
+                                       uint32_t scan_code, bool extended) {
+  if (scan_code == 0) {
+    PopulateWindowsKeyMetadataFromVk(key_code, &scan_code, &extended);
+  }
+#if _WIN32
+  key_code = NormalizeWindowsModifierVk(key_code, scan_code, extended);
+#endif
+
+  RemoteAction action{};
+  action.type = ControlType::keyboard;
+  action.k.flag = is_down ? KeyFlag::key_down : KeyFlag::key_up;
+  action.k.key_value = key_code;
+  action.k.scan_code = scan_code;
+  action.k.extended = extended;
+
+  const std::string target_id = owner_.controlled_remote_id_.empty()
+                                    ? owner_.focused_remote_id_
+                                    : owner_.controlled_remote_id_;
+  const auto props_it = owner_.remote_sessions_.find(target_id);
+  if (!target_id.empty() && props_it != owner_.remote_sessions_.end() &&
+      props_it->second->connection_status_.load() ==
+          ConnectionStatus::Connected &&
+      props_it->second->peer_) {
+    const std::string message = action.to_json();
+    const int result = SendReliableDataFrame(
+        props_it->second->peer_, message.c_str(), message.size(),
+        props_it->second->keyboard_label_.c_str());
+    if (result != 0) {
+      LOG_WARN("Send keyboard command failed, remote_id={}, ret={}", target_id,
+               result);
+    }
+  }
+
+  TrackPressedKey(key_code, is_down, scan_code, extended);
+  return 0;
+}
+
+bool KeyboardController::InjectRemoteKey(int key_code, bool is_down,
+                                         uint32_t scan_code, bool extended) {
+#if _WIN32
+  if (owner_.local_service_status_received_ &&
+      IsSecureDesktopInteractionRequired(owner_.local_interactive_stage_)) {
+    const std::string response = SendCrossDeskSecureDesktopKeyInput(
+        key_code, is_down, scan_code, extended, 1000);
+    const auto json = nlohmann::json::parse(response, nullptr, false);
+    if (json.is_discarded() || !json.value("ok", false)) {
+      RemoteAction action{};
+      action.type = ControlType::keyboard;
+      action.k.key_value = static_cast<size_t>(key_code);
+      action.k.scan_code = scan_code;
+      action.k.extended = extended;
+      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, "
+            "key_code={}, is_down={}, response={}",
+            key_code, is_down, response);
+        return true;
+      }
+
+      LogSecureDesktopInputBlocked(
+          &owner_.last_local_secure_input_block_log_tick_,
+          owner_.local_interactive_stage_.c_str());
+      LOG_WARN(
+          "Secure desktop keyboard injection failed, key_code={}, is_down={}, "
+          "response={}",
+          key_code, is_down, response);
+      return false;
+    }
+    return true;
+  }
+#endif
+  return owner_.devices_.SendKeyboardCommand(key_code, is_down, scan_code,
+                                             extended);
+}
+
+void KeyboardController::ApplyRemoteEvent(const std::string& remote_id,
+                                          const RemoteAction& action) {
+  const int key_code = static_cast<int>(action.k.key_value);
+  const bool is_down = action.k.flag == KeyFlag::key_down;
+  const bool injected =
+      InjectRemoteKey(key_code, is_down, action.k.scan_code, action.k.extended);
+
+  std::lock_guard<std::mutex> lock(remote_states_mutex_);
+  auto& state = remote_states_[remote_id];
+  state.last_seen_tick = static_cast<uint32_t>(SDL_GetTicks());
+  if (is_down && injected) {
+    state.pressed_keys[key_code] =
+        PressedKey{key_code, action.k.scan_code, action.k.extended};
+  } else if (!is_down && injected) {
+    state.pressed_keys.erase(key_code);
+  }
+}
+
+void KeyboardController::ApplyRemoteState(const std::string& remote_id,
+                                          const RemoteAction& action) {
+  std::vector<PressedKey> keys_to_release;
+  std::vector<PressedKey> keys_to_press;
+  {
+    std::lock_guard<std::mutex> lock(remote_states_mutex_);
+    auto& state = remote_states_[remote_id];
+    if (action.ks.seq != 0 && state.last_seq != 0 &&
+        static_cast<int32_t>(action.ks.seq - state.last_seq) <= 0) {
+      return;
+    }
+
+    state.last_seq = action.ks.seq;
+    state.last_seen_tick = static_cast<uint32_t>(SDL_GetTicks());
+    state.keyboard_state_seen = true;
+
+    std::unordered_map<int, PressedKey> desired_keys;
+    const size_t count =
+        (std::min)(action.ks.pressed_count, kMaxKeyboardStateKeys);
+    for (size_t index = 0; index < count; ++index) {
+      const auto& key = action.ks.pressed_keys[index];
+      const int key_code = static_cast<int>(key.key_value);
+      desired_keys[key_code] =
+          PressedKey{key_code, key.scan_code, key.extended};
+    }
+    for (const auto& [key_code, key] : state.pressed_keys) {
+      if (desired_keys.find(key_code) == desired_keys.end()) {
+        keys_to_release.push_back(key);
+      }
+    }
+    for (const auto& [key_code, key] : desired_keys) {
+      if (state.pressed_keys.find(key_code) == state.pressed_keys.end()) {
+        keys_to_press.push_back(key);
+      }
+    }
+  }
+
+  for (const PressedKey& key : keys_to_release) {
+    if (InjectRemoteKey(key.key_code, false, key.scan_code, key.extended)) {
+      std::lock_guard<std::mutex> lock(remote_states_mutex_);
+      const auto state_it = remote_states_.find(remote_id);
+      if (state_it != remote_states_.end()) {
+        state_it->second.pressed_keys.erase(key.key_code);
+      }
+    }
+  }
+  for (const PressedKey& key : keys_to_press) {
+    if (InjectRemoteKey(key.key_code, true, key.scan_code, key.extended)) {
+      std::lock_guard<std::mutex> lock(remote_states_mutex_);
+      remote_states_[remote_id].pressed_keys[key.key_code] = key;
+    }
+  }
+}
+
+void KeyboardController::ReleaseRemotePressedKeys(const std::string& remote_id,
+                                                  const char* reason) {
+  std::vector<PressedKey> keys_to_release;
+  {
+    std::lock_guard<std::mutex> lock(remote_states_mutex_);
+    const auto state_it = remote_states_.find(remote_id);
+    if (state_it == remote_states_.end()) {
+      return;
+    }
+    for (const auto& [_, key] : state_it->second.pressed_keys) {
+      keys_to_release.push_back(key);
+    }
+    remote_states_.erase(state_it);
+  }
+
+  if (!keys_to_release.empty()) {
+    LOG_WARN("Releasing {} remote keyboard keys for remote_id={}, reason={}",
+             keys_to_release.size(), remote_id, reason ? reason : "unknown");
+  }
+  for (const PressedKey& key : keys_to_release) {
+    InjectRemoteKey(key.key_code, false, key.scan_code, key.extended);
+  }
+}
+
+void KeyboardController::CheckRemoteTimeouts() {
+  const uint32_t now = static_cast<uint32_t>(SDL_GetTicks());
+  std::vector<std::string> timed_out_remotes;
+  {
+    std::lock_guard<std::mutex> lock(remote_states_mutex_);
+    for (const auto& [remote_id, state] : remote_states_) {
+      if (state.keyboard_state_seen && !state.pressed_keys.empty() &&
+          state.last_seen_tick != 0 &&
+          now - state.last_seen_tick > kRemoteReleaseTimeoutMs) {
+        timed_out_remotes.push_back(remote_id);
+      }
+    }
+  }
+  for (const std::string& remote_id : timed_out_remotes) {
+    ReleaseRemotePressedKeys(remote_id, "keyboard_heartbeat_timeout");
+  }
+}
+
+}  // namespace crossdesk

apps/desktop/src/gui/features/input/keyboard_controller.h

@@ -0,0 +1,65 @@
+#ifndef CROSSDESK_GUI_KEYBOARD_CONTROLLER_H_
+#define CROSSDESK_GUI_KEYBOARD_CONTROLLER_H_
+
+#include <cstdint>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+#include <remote_action.h>
+
+#include "device_controller.h"
+
+namespace crossdesk {
+
+class GuiRuntime;
+
+// Synchronizes local and remote keyboard state, including heartbeat recovery
+// for keys whose key-up event was lost during a connection interruption.
+class KeyboardController {
+public:
+  explicit KeyboardController(GuiRuntime &owner);
+
+  int SendKeyCommand(int key_code, bool is_down, uint32_t scan_code = 0,
+                     bool extended = false);
+  void ForceReleasePressedKeys();
+  void SendHeartbeat(bool force);
+  void ApplyRemoteEvent(const std::string &remote_id,
+                        const RemoteAction &remote_action);
+  void ApplyRemoteState(const std::string &remote_id,
+                        const RemoteAction &remote_action);
+  void ReleaseRemotePressedKeys(const std::string &remote_id,
+                                const char *reason);
+  void CheckRemoteTimeouts();
+
+private:
+  struct PressedKey {
+    int key_code = 0;
+    uint32_t scan_code = 0;
+    bool extended = false;
+  };
+
+  struct RemoteState {
+    std::unordered_map<int, PressedKey> pressed_keys;
+    uint32_t last_seq = 0;
+    uint32_t last_seen_tick = 0;
+    bool keyboard_state_seen = false;
+  };
+
+  void TrackPressedKey(int key_code, bool is_down, uint32_t scan_code,
+                       bool extended);
+  bool InjectRemoteKey(int key_code, bool is_down, uint32_t scan_code,
+                       bool extended);
+
+  GuiRuntime &owner_;
+  std::unordered_map<int, PressedKey> pressed_keys_;
+  std::mutex pressed_keys_mutex_;
+  uint32_t state_sequence_ = 0;
+  uint32_t last_heartbeat_tick_ = 0;
+  std::unordered_map<std::string, RemoteState> remote_states_;
+  std::mutex remote_states_mutex_;
+};
+
+} // namespace crossdesk
+
+#endif // CROSSDESK_GUI_KEYBOARD_CONTROLLER_H_

apps/desktop/src/gui/features/settings/settings_manager.cpp

@@ -0,0 +1,622 @@
+#include "features/settings/settings_manager.h"
+
+#include <chrono>
+#include <cstddef>
+#include <cstdio>
+#include <cstring>
+#include <exception>
+#include <filesystem>
+#include <fstream>
+#include <functional>
+#include <memory>
+#include <string>
+#include <thread>
+
+#if defined(_WIN32)
+#include <io.h>
+#include <windows.h>
+#else
+#include <fcntl.h>
+#include <unistd.h>
+#endif
+
+#include "localization.h"
+#include "rd_log.h"
+#include "runtime/gui_runtime.h"
+
+namespace crossdesk {
+namespace {
+
+constexpr uint32_t kCacheV3Magic = 0x33444358;  // "XCD3"
+constexpr uint32_t kCacheV3Version = 3;
+
+template <size_t Size>
+void CopyString(char (&destination)[Size], const char *source) {
+  static_assert(Size > 0);
+  std::memset(destination, 0, Size);
+  if (source) {
+    std::strncpy(destination, source, Size - 1);
+  }
+}
+
+uint32_t CacheChecksum(const void *data, size_t size) {
+  const auto *bytes = static_cast<const unsigned char *>(data);
+  uint32_t hash = 2166136261u;
+  for (size_t i = 0; i < size; ++i) {
+    hash ^= bytes[i];
+    hash *= 16777619u;
+  }
+  return hash;
+}
+
+std::filesystem::path TemporaryPathFor(
+    const std::filesystem::path &target) {
+  const auto timestamp = std::chrono::steady_clock::now()
+                             .time_since_epoch()
+                             .count();
+  const auto thread_id =
+      std::hash<std::thread::id>{}(std::this_thread::get_id());
+  std::filesystem::path temporary = target;
+  temporary += ".tmp-" + std::to_string(timestamp) + "-" +
+               std::to_string(thread_id);
+  return temporary;
+}
+
+bool FlushFileToDisk(FILE *file) {
+  if (!file || std::fflush(file) != 0) {
+    return false;
+  }
+#if defined(_WIN32)
+  return _commit(_fileno(file)) == 0;
+#else
+  return fsync(fileno(file)) == 0;
+#endif
+}
+
+bool ReplaceFileAtomically(const std::filesystem::path &temporary,
+                           const std::filesystem::path &target) {
+#if defined(_WIN32)
+  return MoveFileExW(temporary.c_str(), target.c_str(),
+                     MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) != 0;
+#else
+  if (::rename(temporary.c_str(), target.c_str()) != 0) {
+    return false;
+  }
+
+  const std::filesystem::path parent = target.parent_path().empty()
+                                           ? std::filesystem::path(".")
+                                           : target.parent_path();
+  int directory_flags = O_RDONLY;
+#if defined(O_DIRECTORY)
+  directory_flags |= O_DIRECTORY;
+#endif
+  const int directory = open(parent.c_str(), directory_flags);
+  if (directory >= 0) {
+    const bool synced = fsync(directory) == 0;
+    close(directory);
+    return synced;
+  }
+  return false;
+#endif
+}
+
+bool WriteFileAtomically(const std::filesystem::path &target,
+                         const void *data, size_t size) {
+  std::error_code ec;
+  const std::filesystem::path parent = target.parent_path();
+  if (!parent.empty()) {
+    std::filesystem::create_directories(parent, ec);
+    if (ec) {
+      return false;
+    }
+  }
+
+  const std::filesystem::path temporary = TemporaryPathFor(target);
+#if defined(_WIN32)
+  FILE *file = _wfopen(temporary.c_str(), L"wb");
+#else
+  FILE *file = std::fopen(temporary.c_str(), "wb");
+#endif
+  if (!file) {
+    return false;
+  }
+
+  const bool written = std::fwrite(data, 1, size, file) == size;
+  const bool flushed = written && FlushFileToDisk(file);
+  const bool closed = std::fclose(file) == 0;
+  if (!written || !flushed || !closed ||
+      !ReplaceFileAtomically(temporary, target)) {
+    std::filesystem::remove(temporary, ec);
+    return false;
+  }
+  return true;
+}
+
+} // namespace
+
+SettingsManager::SettingsManager(GuiRuntime &owner) : owner_(owner) {}
+
+int SettingsManager::Save() {
+  std::lock_guard<std::mutex> lock(cache_mutex_);
+  return SaveLocked();
+}
+
+int SettingsManager::SaveLocked() {
+  CopyString(cache_v2_.client_id_with_password,
+             owner_.client_id_with_password_);
+  std::memcpy(cache_v2_.key, owner_.aes128_key_, sizeof(owner_.aes128_key_));
+  std::memcpy(cache_v2_.iv, owner_.aes128_iv_, sizeof(owner_.aes128_iv_));
+  CopyString(cache_v2_.self_hosted_id, owner_.self_hosted_id_);
+
+  cache_v3_.magic = kCacheV3Magic;
+  cache_v3_.version = kCacheV3Version;
+  cache_v3_.base = cache_v2_;
+  cache_v3_.pending_identity[sizeof(cache_v3_.pending_identity) - 1] = '\0';
+  cache_v3_.pending_server_host[sizeof(cache_v3_.pending_server_host) - 1] =
+      '\0';
+  cache_v3_.pending_request_id[sizeof(cache_v3_.pending_request_id) - 1] =
+      '\0';
+  cache_v3_.checksum =
+      CacheChecksum(&cache_v3_, offsetof(CacheV3, checksum));
+
+  if (!WriteFileAtomically(owner_.cache_path_ + "/secure_cache_v3.enc",
+                           &cache_v3_, sizeof(cache_v3_))) {
+    return -1;
+  }
+
+  if (!WriteFileAtomically(owner_.cache_path_ + "/secure_cache_v2.enc",
+                           &cache_v2_, sizeof(cache_v2_))) {
+    LOG_WARN("Failed to update legacy v2 credential cache");
+  }
+
+  // Keep writing the legacy cache while older installations may still read it.
+  CopyString(cache_v1_.client_id_with_password,
+             owner_.client_id_with_password_);
+  std::memcpy(cache_v1_.key, owner_.aes128_key_, sizeof(owner_.aes128_key_));
+  std::memcpy(cache_v1_.iv, owner_.aes128_iv_, sizeof(owner_.aes128_iv_));
+  if (!WriteFileAtomically(owner_.cache_path_ + "/secure_cache.enc",
+                           &cache_v1_, sizeof(cache_v1_))) {
+    LOG_WARN("Failed to update legacy v1 credential cache");
+  }
+
+  return 0;
+}
+
+bool SettingsManager::ReadV3Locked() {
+  std::ifstream cache_file(owner_.cache_path_ + "/secure_cache_v3.enc",
+                           std::ios::binary);
+  if (!cache_file) {
+    return false;
+  }
+
+  CacheV3 loaded{};
+  cache_file.read(reinterpret_cast<char *>(&loaded), sizeof(loaded));
+  if (cache_file.gcount() != static_cast<std::streamsize>(sizeof(loaded)) ||
+      loaded.magic != kCacheV3Magic ||
+      loaded.version != kCacheV3Version ||
+      loaded.checksum != CacheChecksum(&loaded, offsetof(CacheV3, checksum))) {
+    LOG_WARN("Ignore invalid v3 credential cache");
+    return false;
+  }
+
+  loaded.base.client_id_with_password
+      [sizeof(loaded.base.client_id_with_password) - 1] = '\0';
+  loaded.base.self_hosted_id[sizeof(loaded.base.self_hosted_id) - 1] = '\0';
+  loaded.pending_identity[sizeof(loaded.pending_identity) - 1] = '\0';
+  loaded.pending_server_host[sizeof(loaded.pending_server_host) - 1] = '\0';
+  loaded.pending_request_id[sizeof(loaded.pending_request_id) - 1] = '\0';
+  cache_v3_ = loaded;
+  cache_v2_ = loaded.base;
+  return true;
+}
+
+bool SettingsManager::ReadV2Locked() {
+  std::ifstream cache_v2_file(owner_.cache_path_ + "/secure_cache_v2.enc",
+                              std::ios::binary);
+  if (!cache_v2_file) {
+    return false;
+  }
+  cache_v2_file.read(reinterpret_cast<char *>(&cache_v2_), sizeof(cache_v2_));
+  if (cache_v2_file.gcount() !=
+      static_cast<std::streamsize>(sizeof(cache_v2_))) {
+    return false;
+  }
+  cache_v2_
+      .client_id_with_password[sizeof(cache_v2_.client_id_with_password) - 1] =
+      '\0';
+  cache_v2_.self_hosted_id[sizeof(cache_v2_.self_hosted_id) - 1] = '\0';
+  return true;
+}
+
+int SettingsManager::Load() {
+  std::unique_lock<std::mutex> lock(cache_mutex_);
+
+  const bool loaded_v3 = ReadV3Locked();
+  if (loaded_v3 || ReadV2Locked()) {
+    CopyString(owner_.client_id_with_password_,
+               cache_v2_.client_id_with_password);
+    CopyString(owner_.self_hosted_id_, cache_v2_.self_hosted_id);
+    std::memcpy(owner_.aes128_key_, cache_v2_.key, sizeof(cache_v2_.key));
+    std::memcpy(owner_.aes128_iv_, cache_v2_.iv, sizeof(cache_v2_.iv));
+    if (loaded_v3) {
+      LOG_INFO("Load settings from v3 cache file");
+    } else {
+      cache_v3_ = {};
+      SaveLocked();
+      LOG_INFO("Migrated settings from v2 to v3 cache file");
+    }
+  } else {
+    std::ifstream cache_v1_file(owner_.cache_path_ + "/secure_cache.enc",
+                                std::ios::binary);
+    if (!cache_v1_file) {
+      lock.unlock();
+
+      std::memset(owner_.password_saved_, 0, sizeof(owner_.password_saved_));
+      std::memset(owner_.aes128_key_, 0, sizeof(owner_.aes128_key_));
+      std::memset(owner_.aes128_iv_, 0, sizeof(owner_.aes128_iv_));
+      std::memset(owner_.self_hosted_id_, 0, sizeof(owner_.self_hosted_id_));
+
+      owner_.thumbnail_ =
+          std::make_shared<Thumbnail>(owner_.cache_path_ + "/thumbnails/");
+      owner_.thumbnail_->GetKeyAndIv(owner_.aes128_key_, owner_.aes128_iv_);
+      owner_.thumbnail_->DeleteAllFilesInDirectory();
+
+      Save();
+      return -1;
+    }
+
+    cache_v1_file.read(reinterpret_cast<char *>(&cache_v1_), sizeof(cache_v1_));
+    cache_v1_
+        .client_id_with_password[sizeof(cache_v1_.client_id_with_password) -
+                                 1] = '\0';
+
+    CopyString(cache_v2_.client_id_with_password,
+               cache_v1_.client_id_with_password);
+    std::memcpy(cache_v2_.key, cache_v1_.key, sizeof(cache_v1_.key));
+    std::memcpy(cache_v2_.iv, cache_v1_.iv, sizeof(cache_v1_.iv));
+    std::memset(cache_v2_.self_hosted_id, 0, sizeof(cache_v2_.self_hosted_id));
+
+    CopyString(owner_.client_id_with_password_,
+               cache_v1_.client_id_with_password);
+    std::memset(owner_.self_hosted_id_, 0, sizeof(owner_.self_hosted_id_));
+    std::memcpy(owner_.aes128_key_, cache_v1_.key, sizeof(cache_v1_.key));
+    std::memcpy(owner_.aes128_iv_, cache_v1_.iv, sizeof(cache_v1_.iv));
+
+    cache_v3_ = {};
+    SaveLocked();
+    LOG_INFO("Migrated settings from v1 to v3 cache file");
+  }
+
+  lock.unlock();
+
+  ActivateCachedPublicIdentity();
+
+  owner_.thumbnail_ =
+      std::make_shared<Thumbnail>(owner_.cache_path_ + "/thumbnails/",
+                                  owner_.aes128_key_, owner_.aes128_iv_);
+
+  owner_.language_button_value_ = localization::detail::ClampLanguageIndex(
+      static_cast<int>(owner_.config_center_->GetLanguage()));
+  owner_.video_quality_button_value_ =
+      static_cast<int>(owner_.config_center_->GetVideoQuality());
+  owner_.video_frame_rate_button_value_ =
+      static_cast<int>(owner_.config_center_->GetVideoFrameRate());
+  owner_.video_encode_format_button_value_ =
+      static_cast<int>(owner_.config_center_->GetVideoEncodeFormat());
+  owner_.enable_hardware_video_codec_ =
+      owner_.config_center_->IsHardwareVideoCodec();
+  owner_.enable_turn_ = owner_.config_center_->IsEnableTurn();
+  owner_.enable_srtp_ = owner_.config_center_->IsEnableSrtp();
+  owner_.enable_self_hosted_ = owner_.config_center_->IsSelfHosted();
+  owner_.enable_autostart_ = owner_.config_center_->IsEnableAutostart();
+  owner_.enable_daemon_ = owner_.config_center_->IsEnableDaemon();
+#if _WIN32 && CROSSDESK_PORTABLE
+  owner_.portable_service_prompt_suppressed_ =
+      owner_.config_center_->IsPortableServicePromptSuppressed();
+  owner_.portable_service_do_not_remind_ =
+      owner_.portable_service_prompt_suppressed_;
+#endif
+
+  const std::string saved_path =
+      owner_.config_center_->GetFileTransferSavePath();
+  CopyString(owner_.file_transfer_save_path_buf_, saved_path.c_str());
+  owner_.file_transfer_save_path_last_ = saved_path;
+
+  owner_.language_button_value_last_ = owner_.language_button_value_;
+  owner_.video_quality_button_value_last_ = owner_.video_quality_button_value_;
+  owner_.video_encode_format_button_value_last_ =
+      owner_.video_encode_format_button_value_;
+  owner_.enable_hardware_video_codec_last_ =
+      owner_.enable_hardware_video_codec_;
+  owner_.enable_turn_last_ = owner_.enable_turn_;
+  owner_.enable_srtp_last_ = owner_.enable_srtp_;
+  owner_.enable_self_hosted_last_ = owner_.enable_self_hosted_;
+  owner_.enable_autostart_last_ = owner_.enable_autostart_;
+
+  LOG_INFO("Load settings from cache file");
+  return 0;
+}
+
+bool SettingsManager::LoadCachedSelfHostedIdentity() {
+  std::lock_guard<std::mutex> lock(cache_mutex_);
+  if ((!ReadV3Locked() && !ReadV2Locked()) ||
+      cache_v2_.self_hosted_id[0] == '\0') {
+    std::memset(owner_.self_hosted_id_, 0, sizeof(owner_.self_hosted_id_));
+    std::memset(owner_.client_id_, 0, sizeof(owner_.client_id_));
+    std::memset(owner_.password_saved_, 0, sizeof(owner_.password_saved_));
+    return false;
+  }
+
+  CopyString(owner_.self_hosted_id_, cache_v2_.self_hosted_id);
+  const char *at_pos = std::strchr(owner_.self_hosted_id_, '@');
+  if (at_pos == nullptr) {
+    CopyString(owner_.client_id_, owner_.self_hosted_id_);
+    std::memset(owner_.password_saved_, 0, sizeof(owner_.password_saved_));
+  } else {
+    const std::string id(owner_.self_hosted_id_,
+                         at_pos - owner_.self_hosted_id_);
+    CopyString(owner_.client_id_, id.c_str());
+    CopyString(owner_.password_saved_, at_pos + 1);
+  }
+  return true;
+}
+
+bool SettingsManager::ActivateCachedPublicIdentity() {
+  if (owner_.client_id_with_password_[0] == '\0') {
+    std::memset(owner_.client_id_, 0, sizeof(owner_.client_id_));
+    std::memset(owner_.password_saved_, 0, sizeof(owner_.password_saved_));
+    return false;
+  }
+
+  const char *at_pos = std::strchr(owner_.client_id_with_password_, '@');
+  if (at_pos == nullptr) {
+    CopyString(owner_.client_id_, owner_.client_id_with_password_);
+    std::memset(owner_.password_saved_, 0, sizeof(owner_.password_saved_));
+  } else {
+    const std::string id(owner_.client_id_with_password_,
+                         at_pos - owner_.client_id_with_password_);
+    CopyString(owner_.client_id_, id.c_str());
+    CopyString(owner_.password_saved_, at_pos + 1);
+  }
+  return owner_.client_id_[0] != '\0';
+}
+
+void SettingsManager::ActivateIdentity(const char *identity,
+                                       bool self_hosted) {
+  if (!identity) {
+    return;
+  }
+
+  if (self_hosted) {
+    CopyString(owner_.self_hosted_id_, identity);
+  } else {
+    CopyString(owner_.client_id_with_password_, identity);
+  }
+
+  const char *at_pos = std::strchr(identity, '@');
+  if (at_pos == nullptr) {
+    CopyString(owner_.client_id_, identity);
+    std::memset(owner_.password_saved_, 0, sizeof(owner_.password_saved_));
+    return;
+  }
+
+  const std::string id(identity, at_pos - identity);
+  CopyString(owner_.client_id_, id.c_str());
+  CopyString(owner_.password_saved_, at_pos + 1);
+}
+
+bool SettingsManager::StagePendingPasswordChange(
+    const std::string &identity, bool self_hosted,
+    const std::string &server_host, int server_port,
+    const std::string &request_id) {
+  if (identity.empty() || identity.size() >= sizeof(cache_v3_.pending_identity) ||
+      server_host.empty() ||
+      server_host.size() >= sizeof(cache_v3_.pending_server_host) ||
+      server_port <= 0 || request_id.empty() ||
+      request_id.size() >= sizeof(cache_v3_.pending_request_id)) {
+    return false;
+  }
+
+  std::lock_guard<std::mutex> lock(cache_mutex_);
+  if (cache_v3_.pending_identity[0] != '\0' &&
+      (cache_v3_.pending_self_hosted != self_hosted ||
+       cache_v3_.pending_server_port != server_port ||
+       server_host != cache_v3_.pending_server_host ||
+       request_id != cache_v3_.pending_request_id)) {
+    LOG_WARN("Refuse to overwrite an unresolved password change");
+    return false;
+  }
+  const CacheV3 previous = cache_v3_;
+  CopyString(cache_v3_.pending_identity, identity.c_str());
+  CopyString(cache_v3_.pending_server_host, server_host.c_str());
+  cache_v3_.pending_server_port = server_port;
+  cache_v3_.pending_self_hosted = self_hosted;
+  CopyString(cache_v3_.pending_request_id, request_id.c_str());
+  if (SaveLocked() != 0) {
+    cache_v3_ = previous;
+    return false;
+  }
+  return true;
+}
+
+std::string SettingsManager::PendingPasswordChangeIdentity(
+    bool self_hosted, const std::string &server_host, int server_port) const {
+  std::lock_guard<std::mutex> lock(cache_mutex_);
+  if (cache_v3_.pending_identity[0] == '\0' ||
+      cache_v3_.pending_self_hosted != self_hosted ||
+      cache_v3_.pending_server_port != server_port ||
+      server_host != cache_v3_.pending_server_host) {
+    return {};
+  }
+  return cache_v3_.pending_identity;
+}
+
+bool SettingsManager::PromotePendingPasswordChange() {
+  std::lock_guard<std::mutex> lock(cache_mutex_);
+  if (cache_v3_.pending_identity[0] == '\0') {
+    return true;
+  }
+
+  const CacheV3 previous = cache_v3_;
+  const std::string identity = cache_v3_.pending_identity;
+  const bool self_hosted = cache_v3_.pending_self_hosted;
+  ActivateIdentity(identity.c_str(), self_hosted);
+  std::memset(cache_v3_.pending_identity, 0,
+              sizeof(cache_v3_.pending_identity));
+  std::memset(cache_v3_.pending_server_host, 0,
+              sizeof(cache_v3_.pending_server_host));
+  cache_v3_.pending_server_port = 0;
+  cache_v3_.pending_self_hosted = false;
+  std::memset(cache_v3_.pending_request_id, 0,
+              sizeof(cache_v3_.pending_request_id));
+  if (SaveLocked() != 0) {
+    // The already-durable pending credential remains the recovery source on
+    // disk. Keep it in memory as well so a reconnect in this process retries
+    // the credential that the server has accepted.
+    cache_v3_ = previous;
+    return false;
+  }
+  return true;
+}
+
+bool SettingsManager::ClearPendingPasswordChange() {
+  std::lock_guard<std::mutex> lock(cache_mutex_);
+  if (cache_v3_.pending_identity[0] == '\0') {
+    return true;
+  }
+
+  const CacheV3 previous = cache_v3_;
+  std::memset(cache_v3_.pending_identity, 0,
+              sizeof(cache_v3_.pending_identity));
+  std::memset(cache_v3_.pending_server_host, 0,
+              sizeof(cache_v3_.pending_server_host));
+  cache_v3_.pending_server_port = 0;
+  cache_v3_.pending_self_hosted = false;
+  std::memset(cache_v3_.pending_request_id, 0,
+              sizeof(cache_v3_.pending_request_id));
+  if (SaveLocked() != 0) {
+    cache_v3_ = previous;
+    return false;
+  }
+  return true;
+}
+
+void SettingsManager::PersistSelfHostedIdentity(const char *client_id) {
+  if (!client_id) {
+    return;
+  }
+
+  std::lock_guard<std::mutex> lock(cache_mutex_);
+  CopyString(owner_.self_hosted_id_, client_id);
+  if (SaveLocked() != 0) {
+    LOG_ERROR("Failed to persist self-hosted identity atomically");
+  }
+}
+
+int SettingsManager::LoadRecentConnectionAliases() {
+  recent_connection_aliases_.clear();
+
+  std::ifstream alias_file(owner_.cache_path_ +
+                           "/recent_connection_aliases.json");
+  if (!alias_file.good()) {
+    return 0;
+  }
+
+  try {
+    nlohmann::json alias_json;
+    alias_file >> alias_json;
+
+    const nlohmann::json *aliases = &alias_json;
+    if (alias_json.contains("aliases") && alias_json["aliases"].is_object()) {
+      aliases = &alias_json["aliases"];
+    }
+    if (!aliases->is_object()) {
+      LOG_WARN("Invalid recent connection alias file");
+      return -1;
+    }
+
+    for (auto it = aliases->begin(); it != aliases->end(); ++it) {
+      if (it.value().is_string()) {
+        const std::string remote_id = it.key();
+        const std::string alias = it.value().get<std::string>();
+        if (!remote_id.empty() && !alias.empty()) {
+          recent_connection_aliases_[remote_id] = alias;
+        }
+      }
+    }
+  } catch (const std::exception &e) {
+    LOG_WARN("Load recent connection aliases failed: {}", e.what());
+    return -1;
+  }
+  return 0;
+}
+
+int SettingsManager::SaveRecentConnectionAliases() const {
+  std::error_code ec;
+  std::filesystem::create_directories(owner_.cache_path_, ec);
+  if (ec) {
+    LOG_WARN("Create cache directory failed while saving aliases: {}",
+             ec.message());
+    return -1;
+  }
+
+  nlohmann::json alias_json;
+  alias_json["aliases"] = nlohmann::json::object();
+  for (const auto &[remote_id, alias] : recent_connection_aliases_) {
+    if (!remote_id.empty() && !alias.empty()) {
+      alias_json["aliases"][remote_id] = alias;
+    }
+  }
+
+  std::ofstream alias_file(
+      owner_.cache_path_ + "/recent_connection_aliases.json", std::ios::trunc);
+  if (!alias_file.good()) {
+    LOG_WARN("Open recent connection alias file failed");
+    return -1;
+  }
+  alias_file << alias_json.dump(2);
+  return 0;
+}
+
+std::string SettingsManager::RecentConnectionDisplayName(
+    const Thumbnail::RecentConnection &connection) const {
+  const auto alias_it = recent_connection_aliases_.find(connection.remote_id);
+  if (alias_it != recent_connection_aliases_.end() &&
+      !alias_it->second.empty()) {
+    return alias_it->second;
+  }
+  if (!connection.remote_host_name.empty() &&
+      connection.remote_host_name != "unknown") {
+    return connection.remote_host_name;
+  }
+  return connection.remote_id;
+}
+
+void SettingsManager::BeginEditRecentConnectionAlias(
+    const Thumbnail::RecentConnection &connection) {
+  owner_.edit_connection_alias_remote_id_ = connection.remote_id;
+  std::memset(owner_.edit_connection_alias_, 0,
+              sizeof(owner_.edit_connection_alias_));
+
+  const auto alias_it = recent_connection_aliases_.find(connection.remote_id);
+  const std::string alias = alias_it != recent_connection_aliases_.end()
+                                ? alias_it->second
+                                : RecentConnectionDisplayName(connection);
+  CopyString(owner_.edit_connection_alias_, alias.c_str());
+
+  owner_.focus_on_input_widget_ = true;
+  owner_.show_edit_connection_alias_window_ = true;
+}
+
+void SettingsManager::SetRecentConnectionAlias(const std::string &remote_id,
+                                               const std::string &alias) {
+  if (!remote_id.empty()) {
+    recent_connection_aliases_[remote_id] = alias;
+  }
+}
+
+void SettingsManager::EraseRecentConnectionAlias(const std::string &remote_id) {
+  recent_connection_aliases_.erase(remote_id);
+}
+
+} // namespace crossdesk

apps/desktop/src/gui/features/settings/settings_manager.h

@@ -0,0 +1,114 @@
+#ifndef CROSSDESK_GUI_SETTINGS_MANAGER_H_
+#define CROSSDESK_GUI_SETTINGS_MANAGER_H_
+
+#include <cstdint>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+#include "thumbnail.h"
+
+namespace crossdesk {
+
+class GuiRuntime;
+
+// Owns persistent GUI settings and recent-connection aliases. GuiRuntime keeps
+// only the runtime/UI state that consumes these values.
+class SettingsManager {
+public:
+  explicit SettingsManager(GuiRuntime &owner);
+
+  int Save();
+  int Load();
+
+  int LoadRecentConnectionAliases();
+  int SaveRecentConnectionAliases() const;
+  std::string RecentConnectionDisplayName(
+      const Thumbnail::RecentConnection &connection) const;
+  void
+  BeginEditRecentConnectionAlias(const Thumbnail::RecentConnection &connection);
+  void SetRecentConnectionAlias(const std::string &remote_id,
+                                const std::string &alias);
+  void EraseRecentConnectionAlias(const std::string &remote_id);
+
+  // Loads the cached self-hosted identity into the owner's active connection
+  // fields. Returns true only when a non-empty identity was restored.
+  bool LoadCachedSelfHostedIdentity();
+  // Restores the public-server identity kept in the in-memory cache fields.
+  // This must run when switching away from a self-hosted server so signal
+  // callbacks are matched against the identity used by the replacement peer.
+  bool ActivateCachedPublicIdentity();
+  void PersistSelfHostedIdentity(const char *client_id);
+
+  // Password rotation is deliberately persisted in two phases. The active
+  // credential remains usable while the pending credential records the value
+  // that may already have been committed by the server. On the next launch the
+  // caller can try the pending credential first and safely fall back to the
+  // active credential when the request never reached the server.
+  bool StagePendingPasswordChange(const std::string &identity,
+                                  bool self_hosted,
+                                  const std::string &server_host,
+                                  int server_port,
+                                  const std::string &request_id);
+  std::string PendingPasswordChangeIdentity(
+      bool self_hosted, const std::string &server_host,
+      int server_port) const;
+  bool PromotePendingPasswordChange();
+  bool ClearPendingPasswordChange();
+
+private:
+  struct CacheV1 {
+    char client_id_with_password[17];
+    int language;
+    int video_quality;
+    int video_frame_rate;
+    int video_encode_format;
+    bool enable_hardware_video_codec;
+    bool enable_turn;
+    bool enable_srtp;
+    unsigned char key[16];
+    unsigned char iv[16];
+  };
+
+  struct CacheV2 {
+    char client_id_with_password[17];
+    int language;
+    int video_quality;
+    int video_frame_rate;
+    int video_encode_format;
+    bool enable_hardware_video_codec;
+    bool enable_turn;
+    bool enable_srtp;
+    unsigned char key[16];
+    unsigned char iv[16];
+    char self_hosted_id[17];
+  };
+
+  struct CacheV3 {
+    uint32_t magic;
+    uint32_t version;
+    CacheV2 base;
+    char pending_identity[17];
+    char pending_server_host[256];
+    int pending_server_port;
+    bool pending_self_hosted;
+    char pending_request_id[64];
+    uint32_t checksum;
+  };
+
+  int SaveLocked();
+  bool ReadV3Locked();
+  bool ReadV2Locked();
+  void ActivateIdentity(const char *identity, bool self_hosted);
+
+  GuiRuntime &owner_;
+  CacheV1 cache_v1_{};
+  CacheV2 cache_v2_{};
+  CacheV3 cache_v3_{};
+  mutable std::mutex cache_mutex_;
+  std::unordered_map<std::string, std::string> recent_connection_aliases_;
+};
+
+} // namespace crossdesk
+
+#endif // CROSSDESK_GUI_SETTINGS_MANAGER_H_