[fix] make PipeWire and portal dependencies optional

scripts/linux/pkg_amd64.sh

@@ -8,6 +8,8 @@ APP_VERSION="$1"
 ARCHITECTURE="amd64"
 MAINTAINER="Junkun Di <junkun.di@hotmail.com>"
 DESCRIPTION="A simple cross-platform remote desktop client."
+ALSA_RUNTIME_DEP="libasound2 | libasound2t64"
+PORTAL_RUNTIME_RECOMMENDS="xdg-desktop-portal, xdg-desktop-portal-gtk | xdg-desktop-portal-kde | xdg-desktop-portal-wlr"
 
 # Remove 'v' prefix from version for Debian package (Debian version must start with digit)
 DEB_VERSION="${APP_VERSION#v}"
@@ -41,11 +43,9 @@ Maintainer: $MAINTAINER
 Description: $DESCRIPTION
 Depends: libc6 (>= 2.29), libstdc++6 (>= 9), libx11-6, libxcb1,
  libxcb-randr0, libxcb-xtest0, libxcb-xinerama0, libxcb-shape0,
- libxcb-xkb1, libxcb-xfixes0, libxv1, libxtst6, libasound2,
+ libxcb-xkb1, libxcb-xfixes0, libxv1, libxtst6, $ALSA_RUNTIME_DEP,
- libsndio7.0, libxcb-shm0, libpulse0, libdrm2, libdbus-1-3,
+ libsndio7.0, libxcb-shm0, libpulse0, libdrm2, libdbus-1-3
- libpipewire-0.3-0, xdg-desktop-portal,
+Recommends: $PORTAL_RUNTIME_RECOMMENDS, nvidia-cuda-toolkit
- xdg-desktop-portal-gtk | xdg-desktop-portal-kde | xdg-desktop-portal-wlr
-Recommends: nvidia-cuda-toolkit
 Priority: optional
 Section: utils
 EOF

scripts/linux/pkg_arm64.sh

@@ -8,6 +8,8 @@ APP_VERSION="$1"
 ARCHITECTURE="arm64"
 MAINTAINER="Junkun Di <junkun.di@hotmail.com>"
 DESCRIPTION="A simple cross-platform remote desktop client."
+ALSA_RUNTIME_DEP="libasound2 | libasound2t64"
+PORTAL_RUNTIME_RECOMMENDS="xdg-desktop-portal, xdg-desktop-portal-gtk | xdg-desktop-portal-kde | xdg-desktop-portal-wlr"
 
 # Remove 'v' prefix from version for Debian package (Debian version must start with digit)
 DEB_VERSION="${APP_VERSION#v}"
@@ -41,10 +43,9 @@ Maintainer: $MAINTAINER
 Description: $DESCRIPTION
 Depends: libc6 (>= 2.29), libstdc++6 (>= 9), libx11-6, libxcb1,
  libxcb-randr0, libxcb-xtest0, libxcb-xinerama0, libxcb-shape0,
- libxcb-xkb1, libxcb-xfixes0, libxv1, libxtst6, libasound2,
+ libxcb-xkb1, libxcb-xfixes0, libxv1, libxtst6, $ALSA_RUNTIME_DEP,
- libsndio7.0, libxcb-shm0, libpulse0, libdrm2, libdbus-1-3,
+ libsndio7.0, libxcb-shm0, libpulse0, libdrm2, libdbus-1-3
- libpipewire-0.3-0, xdg-desktop-portal,
+Recommends: $PORTAL_RUNTIME_RECOMMENDS
- xdg-desktop-portal-gtk | xdg-desktop-portal-kde | xdg-desktop-portal-wlr
 Priority: optional
 Section: utils
 EOF

scripts/windows/nsis_script.nsi

@@ -195,14 +195,7 @@ Function RegisterInstalledService
         Abort
     ${EndIf}
 
-    DetailPrint "Starting CrossDesk service"
+    DetailPrint "CrossDesk service registered for on-demand start"
-    ExecWait '"$INSTDIR\CrossDesk.exe" --service-start' $0
-    ${If} $0 != 0
-        ExecWait '"$INSTDIR\CrossDesk.exe" --service-uninstall' $1
-        ExecWait '"$SYSDIR\sc.exe" delete ${PRODUCT_SERVICE_NAME}' $1
-        MessageBox MB_ICONSTOP|MB_OK "The CrossDesk service was registered but could not be started. The installation will be aborted."
-        Abort
-    ${EndIf}
 
     Return
 

src/app/main.cpp

@@ -14,6 +14,7 @@
 
 #ifdef _WIN32
 #include <cstdio>
+
 #include "service_host.h"
 #endif
 
@@ -53,7 +54,8 @@ void PrintServiceCliUsage() {
       << "  --service-uninstall  Remove the installed Windows service\n"
       << "  --service-start      Start the Windows service\n"
       << "  --service-stop       Stop the Windows service\n"
-  << "  --service-sas        Ask the service to send Secure Attention Sequence\n"
+      << "  --service-sas        Ask the service to send Secure Attention "
+         "Sequence\n"
       << "  --service-ping       Ping the service over named pipe IPC\n"
       << "  --service-status     Query service runtime status\n"
       << "  --service-help       Show this help\n";
@@ -87,12 +89,25 @@ bool IsServiceCliCommand(const char* arg) {
          std::strcmp(arg, "--service-uninstall") == 0 ||
          std::strcmp(arg, "--service-start") == 0 ||
          std::strcmp(arg, "--service-stop") == 0 ||
-      std::strcmp(arg, "--service-sas") == 0 ||
+         std::strcmp(arg, "--service-sas") == 0 ||
          std::strcmp(arg, "--service-ping") == 0 ||
          std::strcmp(arg, "--service-status") == 0 ||
          std::strcmp(arg, "--service-help") == 0;
 }
 
+void TryStartManagedWindowsService() {
+  std::filesystem::path service_path = GetSiblingServiceExecutablePath();
+  if (service_path.empty() || !std::filesystem::exists(service_path)) {
+    return;
+  }
+
+  if (!crossdesk::IsCrossDeskServiceInstalled()) {
+    return;
+  }
+
+  crossdesk::StartCrossDeskService();
+}
+
 int HandleServiceCliCommand(const std::string& command) {
   EnsureConsoleForCli();
 
@@ -120,8 +135,7 @@ int HandleServiceCliCommand(const std::string& command) {
 
   if (command == "--service-uninstall") {
     bool success = crossdesk::UninstallCrossDeskService();
-    std::cout << (success ? "uninstall ok" : "uninstall failed")
+    std::cout << (success ? "uninstall ok" : "uninstall failed") << std::endl;
-              << std::endl;
     return success ? 0 : 1;
   }
 
@@ -182,6 +196,10 @@ int main(int argc, char* argv[]) {
     return 0;
   }
 
+#ifdef _WIN32
+  TryStartManagedWindowsService();
+#endif
+
   bool enable_daemon = false;
   auto path_manager = std::make_unique<crossdesk::PathManager>("CrossDesk");
   if (path_manager) {

src/gui/render.h

@@ -62,6 +62,7 @@ class Render {
     std::chrono::steady_clock::time_point file_send_last_update_time_;
     uint64_t file_send_last_bytes_ = 0;
     bool file_transfer_window_visible_ = false;
+    bool file_transfer_window_hovered_ = false;
     std::atomic<uint32_t> current_file_id_{0};
 
     struct QueuedFile {

src/gui/render_callback.cpp

@@ -474,6 +474,12 @@ int Render::ProcessMouseEvent(const SDL_Event& event) {
       continue;
     }
 
+    const bool file_transfer_window_hovered =
+        props->file_transfer_.file_transfer_window_hovered_;
+    const bool overlay_hovered = props->control_bar_hovered_ ||
+                                 props->display_selectable_hovered_ ||
+                                 file_transfer_window_hovered;
+
     const SDL_FRect render_rect = props->stream_render_rect_f_;
     if (render_rect.w <= 1.0f || render_rect.h <= 1.0f) {
       continue;
@@ -517,7 +523,7 @@ int Render::ProcessMouseEvent(const SDL_Event& event) {
         remote_action.m.flag = MouseFlag::move;
       }
 
-      if (props->control_bar_hovered_ || props->display_selectable_hovered_) {
+      if (overlay_hovered) {
         break;
       }
       if (props->peer_) {
@@ -563,7 +569,7 @@ int Render::ProcessMouseEvent(const SDL_Event& event) {
       remote_action.m.x = std::clamp(remote_action.m.x, 0.0f, 1.0f);
       remote_action.m.y = std::clamp(remote_action.m.y, 0.0f, 1.0f);
 
-      if (props->control_bar_hovered_) {
+      if (overlay_hovered) {
         continue;
       }
       if (props->peer_) {

src/gui/windows/file_transfer_window.cpp

@@ -31,6 +31,7 @@ int BitrateDisplay(int bitrate) {
 int Render::FileTransferWindow(
     std::shared_ptr<SubStreamWindowProperties>& props) {
   FileTransferState* state = props ? &props->file_transfer_ : &file_transfer_;
+  state->file_transfer_window_hovered_ = false;
 
   // Only show window if there are files in transfer list or currently
   // transferring
@@ -72,8 +73,6 @@ int Render::FileTransferWindow(
     return 0;
   }
 
-  ImGuiIO& io = ImGui::GetIO();
-
   // Position window at bottom-left of stream window
   // Adjust window size based on number of files
   float file_transfer_window_width = main_window_width_ * 0.6f;
@@ -82,15 +81,25 @@ int Render::FileTransferWindow(
   float pos_x = file_transfer_window_width * 0.05f;
   float pos_y = stream_window_height_ - file_transfer_window_height -
                 file_transfer_window_width * 0.05;
-  float same_line_width = file_transfer_window_width * 0.1f;
+
+  const ImVec2 mouse_pos = ImGui::GetMousePos();
+  const bool mouse_in_window_rect =
+      mouse_pos.x >= pos_x &&
+      mouse_pos.x <= pos_x + file_transfer_window_width &&
+      mouse_pos.y >= pos_y &&
+      mouse_pos.y <= pos_y + file_transfer_window_height;
 
   ImGui::SetNextWindowPos(ImVec2(pos_x, pos_y), ImGuiCond_Always);
   ImGui::SetNextWindowSize(
       ImVec2(file_transfer_window_width, file_transfer_window_height),
       ImGuiCond_Always);
+  if (mouse_in_window_rect) {
+    ImGui::SetNextWindowFocus();
+  }
 
   // Set Chinese font for proper display
-  if (stream_windows_system_chinese_font_) {
+  const bool has_chinese_font = stream_windows_system_chinese_font_ != nullptr;
+  if (has_chinese_font) {
     ImGui::PushFont(stream_windows_system_chinese_font_);
   }
 
@@ -103,24 +112,27 @@ int Render::FileTransferWindow(
 
   ImGui::SetWindowFontScale(0.5f);
   bool window_opened = true;
-  if (ImGui::Begin(
+  const bool show_contents = ImGui::Begin(
-          localization::file_transfer_progress[localization_language_index_]
+      localization::file_transfer_progress[localization_language_index_]
-              .c_str(),
+          .c_str(),
-          &window_opened,
+      &window_opened,
-          ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize |
+      ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize |
-              ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
+          ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
-              ImGuiWindowFlags_NoScrollbar)) {
+          ImGuiWindowFlags_NoScrollbar);
+  ImGui::PopStyleColor(4);
+  ImGui::PopStyleVar(2);
+
+  state->file_transfer_window_hovered_ =
+      mouse_in_window_rect ||
+      ImGui::IsWindowHovered(ImGuiHoveredFlags_RootAndChildWindows);
+
+  if (!window_opened) {
+    state->file_transfer_window_visible_ = false;
+  }
+
+  if (show_contents && window_opened) {
     ImGui::SetWindowFontScale(1.0f);
     ImGui::SetWindowFontScale(0.5f);
-    ImGui::PopStyleColor(4);
-    ImGui::PopStyleVar(2);
-
-    // Close button handling
-    if (!window_opened) {
-      state->file_transfer_window_visible_ = false;
-      ImGui::End();
-      return 0;
-    }
 
     // Display file list
     if (file_list.empty()) {
@@ -225,21 +237,16 @@ int Render::FileTransferWindow(
     }
     ImGui::SetWindowFontScale(1.0f);
     ImGui::SetWindowFontScale(0.5f);
-    ImGui::End();
-    ImGui::SetWindowFontScale(1.0f);
-
-    // Pop Chinese font if it was pushed
-    if (stream_windows_system_chinese_font_) {
-      ImGui::PopFont();
-    }
-  } else {
-    ImGui::PopStyleColor(4);
-    ImGui::PopStyleVar(2);
   }
+
+  ImGui::End();
   ImGui::SetWindowFontScale(1.0f);
 
+  if (has_chinese_font) {
+    ImGui::PopFont();
+  }
+
   return 0;
 }
 
 }  // namespace crossdesk
-

src/screen_capturer/linux/screen_capturer_wayland.cpp

@@ -57,6 +57,11 @@ int ScreenCapturerWayland::Init(const int fps, cb_desktop_data cb) {
     return -1;
   }
 
+  if (!EnsurePipeWireRuntimeAvailable()) {
+    LOG_ERROR("Wayland screen capturer requires PipeWire 0.3 runtime");
+    return -1;
+  }
+
   fps_ = fps;
   callback_ = cb;
   pointer_granted_ = false;

src/screen_capturer/linux/screen_capturer_wayland.h

@@ -52,6 +52,7 @@ class ScreenCapturerWayland : public ScreenCapturer {
   bool SelectPortalDevices();
   bool SelectPortalSource();
   bool StartPortalSession();
+  bool EnsurePipeWireRuntimeAvailable() const;
   bool OpenPipeWireRemote();
   bool SetupPipeWireStream(bool relaxed_connect, PipeWireConnectMode mode);
 

src/screen_capturer/linux/screen_capturer_wayland_pipewire.cpp

@@ -3,6 +3,7 @@
 
 #if CROSSDESK_WAYLAND_BUILD_ENABLED
 
+#include <dlfcn.h>
 #include <unistd.h>
 
 #include <algorithm>
@@ -10,6 +11,7 @@
 #include <cmath>
 #include <cstdint>
 #include <limits>
+#include <mutex>
 #include <thread>
 #include <vector>
 
@@ -20,6 +22,143 @@ namespace crossdesk {
 
 namespace {
 
+struct PipeWireDynamicApi {
+  void* library = nullptr;
+  bool available = false;
+
+  decltype(&::pw_init) init = nullptr;
+  decltype(&::pw_deinit) deinit = nullptr;
+  decltype(&::pw_thread_loop_new) thread_loop_new = nullptr;
+  decltype(&::pw_thread_loop_destroy) thread_loop_destroy = nullptr;
+  decltype(&::pw_thread_loop_get_loop) thread_loop_get_loop = nullptr;
+  decltype(&::pw_thread_loop_start) thread_loop_start = nullptr;
+  decltype(&::pw_thread_loop_stop) thread_loop_stop = nullptr;
+  decltype(&::pw_thread_loop_lock) thread_loop_lock = nullptr;
+  decltype(&::pw_thread_loop_unlock) thread_loop_unlock = nullptr;
+  decltype(&::pw_thread_loop_wait) thread_loop_wait = nullptr;
+  decltype(&::pw_thread_loop_signal) thread_loop_signal = nullptr;
+  decltype(&::pw_context_new) context_new = nullptr;
+  decltype(&::pw_context_destroy) context_destroy = nullptr;
+  decltype(&::pw_context_connect_fd) context_connect_fd = nullptr;
+  decltype(&::pw_properties_new) properties_new = nullptr;
+  decltype(&::pw_properties_set) properties_set = nullptr;
+  decltype(&::pw_stream_new) stream_new = nullptr;
+  decltype(&::pw_stream_add_listener) stream_add_listener = nullptr;
+  decltype(&::pw_stream_state_as_string) stream_state_as_string = nullptr;
+  decltype(&::pw_stream_connect) stream_connect = nullptr;
+  decltype(&::pw_stream_update_params) stream_update_params = nullptr;
+  decltype(&::pw_stream_set_active) stream_set_active = nullptr;
+  decltype(&::pw_stream_disconnect) stream_disconnect = nullptr;
+  decltype(&::pw_stream_destroy) stream_destroy = nullptr;
+  decltype(&::pw_stream_dequeue_buffer) stream_dequeue_buffer = nullptr;
+  decltype(&::pw_stream_queue_buffer) stream_queue_buffer = nullptr;
+  decltype(&::pw_core_disconnect) core_disconnect = nullptr;
+  decltype(&::pw_proxy_destroy) proxy_destroy = nullptr;
+};
+
+template <typename T>
+bool LoadPipeWireSymbol(void* library, T* function, const char* symbol_name) {
+  *function = reinterpret_cast<T>(dlsym(library, symbol_name));
+  if (*function != nullptr) {
+    return true;
+  }
+
+  LOG_ERROR("Unable to find PipeWire symbol {}", symbol_name);
+  return false;
+}
+
+void UnloadPipeWireApi(PipeWireDynamicApi* api) {
+  if (api->library != nullptr) {
+    dlclose(api->library);
+  }
+  *api = PipeWireDynamicApi{};
+}
+
+bool LoadPipeWireApi(PipeWireDynamicApi* api) {
+  static constexpr const char* kPipeWireLibraries[] = {
+      "libpipewire-0.3.so.0",
+      "libpipewire-0.3.so",
+  };
+
+  for (const char* library_name : kPipeWireLibraries) {
+    api->library = dlopen(library_name, RTLD_LAZY | RTLD_LOCAL);
+    if (api->library != nullptr) {
+      break;
+    }
+  }
+
+  if (api->library == nullptr) {
+    LOG_WARN("PipeWire 0.3 runtime library is unavailable");
+    return false;
+  }
+
+  if (!LoadPipeWireSymbol(api->library, &api->init, "pw_init") ||
+      !LoadPipeWireSymbol(api->library, &api->deinit, "pw_deinit") ||
+      !LoadPipeWireSymbol(api->library, &api->thread_loop_new,
+                          "pw_thread_loop_new") ||
+      !LoadPipeWireSymbol(api->library, &api->thread_loop_destroy,
+                          "pw_thread_loop_destroy") ||
+      !LoadPipeWireSymbol(api->library, &api->thread_loop_get_loop,
+                          "pw_thread_loop_get_loop") ||
+      !LoadPipeWireSymbol(api->library, &api->thread_loop_start,
+                          "pw_thread_loop_start") ||
+      !LoadPipeWireSymbol(api->library, &api->thread_loop_stop,
+                          "pw_thread_loop_stop") ||
+      !LoadPipeWireSymbol(api->library, &api->thread_loop_lock,
+                          "pw_thread_loop_lock") ||
+      !LoadPipeWireSymbol(api->library, &api->thread_loop_unlock,
+                          "pw_thread_loop_unlock") ||
+      !LoadPipeWireSymbol(api->library, &api->thread_loop_wait,
+                          "pw_thread_loop_wait") ||
+      !LoadPipeWireSymbol(api->library, &api->thread_loop_signal,
+                          "pw_thread_loop_signal") ||
+      !LoadPipeWireSymbol(api->library, &api->context_new, "pw_context_new") ||
+      !LoadPipeWireSymbol(api->library, &api->context_destroy,
+                          "pw_context_destroy") ||
+      !LoadPipeWireSymbol(api->library, &api->context_connect_fd,
+                          "pw_context_connect_fd") ||
+      !LoadPipeWireSymbol(api->library, &api->properties_new,
+                          "pw_properties_new") ||
+      !LoadPipeWireSymbol(api->library, &api->properties_set,
+                          "pw_properties_set") ||
+      !LoadPipeWireSymbol(api->library, &api->stream_new, "pw_stream_new") ||
+      !LoadPipeWireSymbol(api->library, &api->stream_add_listener,
+                          "pw_stream_add_listener") ||
+      !LoadPipeWireSymbol(api->library, &api->stream_state_as_string,
+                          "pw_stream_state_as_string") ||
+      !LoadPipeWireSymbol(api->library, &api->stream_connect,
+                          "pw_stream_connect") ||
+      !LoadPipeWireSymbol(api->library, &api->stream_update_params,
+                          "pw_stream_update_params") ||
+      !LoadPipeWireSymbol(api->library, &api->stream_set_active,
+                          "pw_stream_set_active") ||
+      !LoadPipeWireSymbol(api->library, &api->stream_disconnect,
+                          "pw_stream_disconnect") ||
+      !LoadPipeWireSymbol(api->library, &api->stream_destroy,
+                          "pw_stream_destroy") ||
+      !LoadPipeWireSymbol(api->library, &api->stream_dequeue_buffer,
+                          "pw_stream_dequeue_buffer") ||
+      !LoadPipeWireSymbol(api->library, &api->stream_queue_buffer,
+                          "pw_stream_queue_buffer") ||
+      !LoadPipeWireSymbol(api->library, &api->core_disconnect,
+                          "pw_core_disconnect") ||
+      !LoadPipeWireSymbol(api->library, &api->proxy_destroy,
+                          "pw_proxy_destroy")) {
+    UnloadPipeWireApi(api);
+    return false;
+  }
+
+  api->available = true;
+  return true;
+}
+
+const PipeWireDynamicApi* GetPipeWireApi() {
+  static PipeWireDynamicApi api;
+  static std::once_flag once;
+  std::call_once(once, []() { LoadPipeWireApi(&api); });
+  return api.available ? &api : nullptr;
+}
+
 const char* PipeWireFormatName(uint32_t spa_format) {
   switch (spa_format) {
     case SPA_VIDEO_FORMAT_BGRx:
@@ -76,6 +215,7 @@ double SnapLikelyFractionalScale(double observed_scale) {
 }
 
 struct PipeWireTargetLookupState {
+  const PipeWireDynamicApi* pipewire = nullptr;
   pw_thread_loop* loop = nullptr;
   uint32_t target_node_id = 0;
   int sync_seq = -1;
@@ -87,11 +227,13 @@ struct PipeWireTargetLookupState {
 std::string LookupPipeWireTargetObjectSerial(pw_core* core,
                                              pw_thread_loop* loop,
                                              uint32_t node_id) {
-  if (!core || !loop || node_id == 0) {
+  const PipeWireDynamicApi* pipewire = GetPipeWireApi();
+  if (!pipewire || !core || !loop || node_id == 0) {
     return "";
   }
 
   PipeWireTargetLookupState state;
+  state.pipewire = pipewire;
   state.loop = loop;
   state.target_node_id = node_id;
 
@@ -138,7 +280,7 @@ std::string LookupPipeWireTargetObjectSerial(pw_core* core,
       return;
     }
     state->done = true;
-    pw_thread_loop_signal(state->loop, false);
+    state->pipewire->thread_loop_signal(state->loop, false);
   };
   core_events.error = [](void* userdata, uint32_t id, int seq, int res,
                          const char* message) {
@@ -152,7 +294,7 @@ std::string LookupPipeWireTargetObjectSerial(pw_core* core,
     LOG_WARN("PipeWire registry lookup error: {}",
              message ? message : "unknown");
     state->done = true;
-    pw_thread_loop_signal(state->loop, false);
+    state->pipewire->thread_loop_signal(state->loop, false);
   };
 
   pw_registry_add_listener(registry, &registry_listener, &registry_events,
@@ -161,12 +303,12 @@ std::string LookupPipeWireTargetObjectSerial(pw_core* core,
   state.sync_seq = pw_core_sync(core, PW_ID_CORE, 0);
 
   while (!state.done) {
-    pw_thread_loop_wait(loop);
+    pipewire->thread_loop_wait(loop);
   }
 
   spa_hook_remove(&registry_listener);
   spa_hook_remove(&core_listener);
-  pw_proxy_destroy(reinterpret_cast<pw_proxy*>(registry));
+  pipewire->proxy_destroy(reinterpret_cast<pw_proxy*>(registry));
   return state.found ? state.object_serial : "";
 }
 
@@ -188,56 +330,68 @@ int BytesPerPixel(uint32_t spa_format) {
 
 }  // namespace
 
+bool ScreenCapturerWayland::EnsurePipeWireRuntimeAvailable() const {
+  return GetPipeWireApi() != nullptr;
+}
+
 bool ScreenCapturerWayland::SetupPipeWireStream(bool relaxed_connect,
                                                 PipeWireConnectMode mode) {
+  const PipeWireDynamicApi* pipewire = GetPipeWireApi();
+  if (!pipewire) {
+    LOG_ERROR("PipeWire 0.3 runtime library is unavailable");
+    return false;
+  }
+
   if (pipewire_fd_ < 0 || pipewire_node_id_ == 0) {
     return false;
   }
 
   if (!pipewire_initialized_) {
-    pw_init(nullptr, nullptr);
+    pipewire->init(nullptr, nullptr);
     pipewire_initialized_ = true;
   }
 
-  pw_thread_loop_ = pw_thread_loop_new("crossdesk-wayland-capture", nullptr);
+  pw_thread_loop_ =
+      pipewire->thread_loop_new("crossdesk-wayland-capture", nullptr);
   if (!pw_thread_loop_) {
     LOG_ERROR("Failed to create PipeWire thread loop");
     return false;
   }
 
-  if (pw_thread_loop_start(pw_thread_loop_) < 0) {
+  if (pipewire->thread_loop_start(pw_thread_loop_) < 0) {
     LOG_ERROR("Failed to start PipeWire thread loop");
     CleanupPipeWire();
     return false;
   }
   pipewire_thread_loop_started_ = true;
 
-  pw_thread_loop_lock(pw_thread_loop_);
+  pipewire->thread_loop_lock(pw_thread_loop_);
 
-  pw_context_ =
+  pw_context_ = pipewire->context_new(
-      pw_context_new(pw_thread_loop_get_loop(pw_thread_loop_), nullptr, 0);
+      pipewire->thread_loop_get_loop(pw_thread_loop_), nullptr, 0);
   if (!pw_context_) {
     LOG_ERROR("Failed to create PipeWire context");
-    pw_thread_loop_unlock(pw_thread_loop_);
+    pipewire->thread_loop_unlock(pw_thread_loop_);
     CleanupPipeWire();
     return false;
   }
 
-  pw_core_ = pw_context_connect_fd(pw_context_, pipewire_fd_, nullptr, 0);
+  pw_core_ =
+      pipewire->context_connect_fd(pw_context_, pipewire_fd_, nullptr, 0);
   if (!pw_core_) {
     LOG_ERROR("Failed to connect to PipeWire remote");
-    pw_thread_loop_unlock(pw_thread_loop_);
+    pipewire->thread_loop_unlock(pw_thread_loop_);
     CleanupPipeWire();
     return false;
   }
   pipewire_fd_ = -1;
 
-  pw_properties* stream_props =
+  pw_properties* stream_props = pipewire->properties_new(
-      pw_properties_new(PW_KEY_MEDIA_TYPE, "Video", PW_KEY_MEDIA_CATEGORY,
+      PW_KEY_MEDIA_TYPE, "Video", PW_KEY_MEDIA_CATEGORY, "Capture",
-                        "Capture", PW_KEY_MEDIA_ROLE, "Screen", nullptr);
+      PW_KEY_MEDIA_ROLE, "Screen", nullptr);
   if (!stream_props) {
     LOG_ERROR("Failed to allocate PipeWire stream properties");
-    pw_thread_loop_unlock(pw_thread_loop_);
+    pipewire->thread_loop_unlock(pw_thread_loop_);
     CleanupPipeWire();
     return false;
   }
@@ -247,8 +401,8 @@ bool ScreenCapturerWayland::SetupPipeWireStream(bool relaxed_connect,
     target_object_serial = LookupPipeWireTargetObjectSerial(
         pw_core_, pw_thread_loop_, pipewire_node_id_);
     if (!target_object_serial.empty()) {
-      pw_properties_set(stream_props, PW_KEY_TARGET_OBJECT,
+      pipewire->properties_set(stream_props, PW_KEY_TARGET_OBJECT,
-                        target_object_serial.c_str());
+                               target_object_serial.c_str());
       LOG_INFO("PipeWire target object serial for node {} is {}",
                pipewire_node_id_, target_object_serial);
     } else {
@@ -260,10 +414,10 @@ bool ScreenCapturerWayland::SetupPipeWireStream(bool relaxed_connect,
   }
 
   pw_stream_ =
-      pw_stream_new(pw_core_, "CrossDesk Wayland Capture", stream_props);
+      pipewire->stream_new(pw_core_, "CrossDesk Wayland Capture", stream_props);
   if (!pw_stream_) {
     LOG_ERROR("Failed to create PipeWire stream");
-    pw_thread_loop_unlock(pw_thread_loop_);
+    pipewire->thread_loop_unlock(pw_thread_loop_);
     CleanupPipeWire();
     return false;
   }
@@ -289,9 +443,11 @@ bool ScreenCapturerWayland::SetupPipeWireStream(bool relaxed_connect,
         return;
       }
 
-      LOG_INFO("PipeWire stream state: {} -> {}",
+      const PipeWireDynamicApi* pipewire = GetPipeWireApi();
-               pw_stream_state_as_string(old_state),
+      LOG_INFO(
-               pw_stream_state_as_string(state));
+          "PipeWire stream state: {} -> {}",
+          pipewire ? pipewire->stream_state_as_string(old_state) : "unknown",
+          pipewire ? pipewire->stream_state_as_string(state) : "unknown");
     };
     events.param_changed = [](void* userdata, uint32_t id,
                               const struct spa_pod* param) {
@@ -369,7 +525,10 @@ bool ScreenCapturerWayland::SetupPipeWireStream(bool relaxed_connect,
               SPA_POD_Int(sizeof(struct spa_meta_header))));
 
       if (self->pw_stream_) {
-        pw_stream_update_params(self->pw_stream_, params, param_count);
+        const PipeWireDynamicApi* pipewire = GetPipeWireApi();
+        if (pipewire) {
+          pipewire->stream_update_params(self->pw_stream_, params, param_count);
+        }
       }
       self->pipewire_format_ready_.store(true);
 
@@ -457,7 +616,7 @@ bool ScreenCapturerWayland::SetupPipeWireStream(bool relaxed_connect,
     return events;
   }();
 
-  pw_stream_add_listener(pw_stream_, listener, &stream_events, this);
+  pipewire->stream_add_listener(pw_stream_, listener, &stream_events, this);
   pipewire_format_ready_.store(false);
   pipewire_stream_start_ms_.store(NowMs());
   pipewire_last_frame_ms_.store(0);
@@ -501,7 +660,7 @@ bool ScreenCapturerWayland::SetupPipeWireStream(bool relaxed_connect,
 
     if (param_count == 0) {
       LOG_ERROR("No valid PipeWire format params were built");
-      pw_thread_loop_unlock(pw_thread_loop_);
+      pipewire->thread_loop_unlock(pw_thread_loop_);
       CleanupPipeWire();
       return false;
     }
@@ -522,12 +681,12 @@ bool ScreenCapturerWayland::SetupPipeWireStream(bool relaxed_connect,
       PipeWireConnectModeName(mode), pipewire_node_id_, target_id,
       target_object_serial.empty() ? "none" : target_object_serial.c_str(),
       relaxed_connect, param_count, fixed_size.width, fixed_size.height);
-  const int ret = pw_stream_connect(
+  const int ret = pipewire->stream_connect(
       pw_stream_, PW_DIRECTION_INPUT, target_id,
       static_cast<pw_stream_flags>(PW_STREAM_FLAG_AUTOCONNECT |
                                    PW_STREAM_FLAG_MAP_BUFFERS),
       param_count > 0 ? params : nullptr, static_cast<uint32_t>(param_count));
-  pw_thread_loop_unlock(pw_thread_loop_);
+  pipewire->thread_loop_unlock(pw_thread_loop_);
 
   if (ret < 0) {
     LOG_ERROR("pw_stream_connect failed: {}", spa_strerror(ret));
@@ -539,16 +698,17 @@ bool ScreenCapturerWayland::SetupPipeWireStream(bool relaxed_connect,
 }
 
 void ScreenCapturerWayland::CleanupPipeWire() {
+  const PipeWireDynamicApi* pipewire = GetPipeWireApi();
   const bool need_lock =
-      pw_thread_loop_ &&
+      pipewire && pw_thread_loop_ &&
       (pw_stream_ != nullptr || pw_core_ != nullptr || pw_context_ != nullptr);
   if (need_lock) {
-    pw_thread_loop_lock(pw_thread_loop_);
+    pipewire->thread_loop_lock(pw_thread_loop_);
   }
 
-  if (pw_stream_) {
+  if (pw_stream_ && pipewire) {
-    pw_stream_set_active(pw_stream_, false);
+    pipewire->stream_set_active(pw_stream_, false);
-    pw_stream_disconnect(pw_stream_);
+    pipewire->stream_disconnect(pw_stream_);
   }
 
   if (stream_listener_) {
@@ -557,33 +717,34 @@ void ScreenCapturerWayland::CleanupPipeWire() {
     stream_listener_ = nullptr;
   }
 
-  if (pw_stream_) {
+  if (pw_stream_ && pipewire) {
-    pw_stream_destroy(pw_stream_);
+    pipewire->stream_destroy(pw_stream_);
-    pw_stream_ = nullptr;
   }
+  pw_stream_ = nullptr;
 
-  if (pw_core_) {
+  if (pw_core_ && pipewire) {
-    pw_core_disconnect(pw_core_);
+    pipewire->core_disconnect(pw_core_);
-    pw_core_ = nullptr;
   }
+  pw_core_ = nullptr;
 
-  if (pw_context_) {
+  if (pw_context_ && pipewire) {
-    pw_context_destroy(pw_context_);
+    pipewire->context_destroy(pw_context_);
-    pw_context_ = nullptr;
   }
+  pw_context_ = nullptr;
 
   if (need_lock) {
-    pw_thread_loop_unlock(pw_thread_loop_);
+    pipewire->thread_loop_unlock(pw_thread_loop_);
   }
 
-  if (pw_thread_loop_) {
+  if (pw_thread_loop_ && pipewire) {
     if (pipewire_thread_loop_started_) {
-      pw_thread_loop_stop(pw_thread_loop_);
+      pipewire->thread_loop_stop(pw_thread_loop_);
       pipewire_thread_loop_started_ = false;
     }
-    pw_thread_loop_destroy(pw_thread_loop_);
+    pipewire->thread_loop_destroy(pw_thread_loop_);
-    pw_thread_loop_ = nullptr;
   }
+  pw_thread_loop_ = nullptr;
+  pipewire_thread_loop_started_ = false;
 
   if (pipewire_fd_ >= 0) {
     close(pipewire_fd_);
@@ -594,23 +755,24 @@ void ScreenCapturerWayland::CleanupPipeWire() {
   pipewire_stream_start_ms_.store(0);
   pipewire_last_frame_ms_.store(0);
 
-  if (pipewire_initialized_) {
+  if (pipewire_initialized_ && pipewire) {
-    pw_deinit();
+    pipewire->deinit();
-    pipewire_initialized_ = false;
   }
+  pipewire_initialized_ = false;
 }
 
 void ScreenCapturerWayland::HandlePipeWireBuffer() {
-  if (!pw_stream_) {
+  const PipeWireDynamicApi* pipewire = GetPipeWireApi();
+  if (!pw_stream_ || !pipewire) {
     return;
   }
 
-  pw_buffer* buffer = pw_stream_dequeue_buffer(pw_stream_);
+  pw_buffer* buffer = pipewire->stream_dequeue_buffer(pw_stream_);
   if (!buffer) {
     return;
   }
 
-  auto requeue = [&]() { pw_stream_queue_buffer(pw_stream_, buffer); };
+  auto requeue = [&]() { pipewire->stream_queue_buffer(pw_stream_, buffer); };
 
   if (paused_) {
     requeue();

src/service/windows/service_host.cpp

@@ -1,5 +1,6 @@
 #include "service_host.h"
 
+#include <Aclapi.h>
 #include <TlHelp32.h>
 #include <Userenv.h>
 #include <WtsApi32.h>
@@ -27,6 +28,9 @@ using Json = nlohmann::json;
 
 constexpr char kSecureDesktopKeyboardIpcCommandPrefix[] = "secure-input-key:";
 constexpr char kSecureDesktopMouseIpcCommandPrefix[] = "secure-input-mouse:";
+constexpr wchar_t kCrossDeskClientProcessName[] = L"crossdesk.exe";
+constexpr DWORD kCrossDeskClientMonitorIntervalMs = 1000;
+constexpr ULONGLONG kCrossDeskClientMonitorStartupGraceMs = 5000;
 
 using SendSasFunction = VOID(WINAPI*)(BOOL);
 
@@ -157,6 +161,97 @@ std::string BuildErrorJson(const char* error, DWORD error_code = 0) {
   return stream.str();
 }
 
+bool HasRunningCrossDeskClientProcess() {
+  HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+  if (snapshot == INVALID_HANDLE_VALUE) {
+    LOG_ERROR("CreateToolhelp32Snapshot failed, error={}", GetLastError());
+    return true;
+  }
+
+  PROCESSENTRY32W entry{};
+  entry.dwSize = sizeof(entry);
+  if (!Process32FirstW(snapshot, &entry)) {
+    DWORD error = GetLastError();
+    CloseHandle(snapshot);
+    if (error != ERROR_NO_MORE_FILES) {
+      LOG_ERROR("Process32FirstW failed, error={}", error);
+      return true;
+    }
+    return false;
+  }
+
+  do {
+    if (_wcsicmp(entry.szExeFile, kCrossDeskClientProcessName) == 0) {
+      CloseHandle(snapshot);
+      return true;
+    }
+  } while (Process32NextW(snapshot, &entry));
+
+  DWORD error = GetLastError();
+  CloseHandle(snapshot);
+  if (error != ERROR_NO_MORE_FILES) {
+    LOG_ERROR("Process32NextW failed, error={}", error);
+    return true;
+  }
+
+  return false;
+}
+
+bool GrantCrossDeskServiceStartAccessToAuthenticatedUsers(SC_HANDLE service) {
+  if (service == nullptr) {
+    return false;
+  }
+
+  PACL existing_dacl = nullptr;
+  PACL updated_dacl = nullptr;
+  PSECURITY_DESCRIPTOR security_descriptor = nullptr;
+  DWORD error =
+      GetSecurityInfo(service, SE_SERVICE, DACL_SECURITY_INFORMATION, nullptr,
+                      nullptr, &existing_dacl, nullptr, &security_descriptor);
+  if (error != ERROR_SUCCESS) {
+    LOG_ERROR("GetSecurityInfo failed, error={}", error);
+    return false;
+  }
+
+  BYTE sid_buffer[SECURITY_MAX_SID_SIZE] = {0};
+  DWORD sid_size = sizeof(sid_buffer);
+  if (!CreateWellKnownSid(WinAuthenticatedUserSid, nullptr, sid_buffer,
+                          &sid_size)) {
+    error = GetLastError();
+    LOG_ERROR("CreateWellKnownSid failed, error={}", error);
+    LocalFree(security_descriptor);
+    return false;
+  }
+
+  EXPLICIT_ACCESSW access{};
+  access.grfAccessPermissions = SERVICE_START | SERVICE_QUERY_STATUS;
+  access.grfAccessMode = SET_ACCESS;
+  access.grfInheritance = NO_INHERITANCE;
+  access.Trustee.TrusteeForm = TRUSTEE_IS_SID;
+  access.Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
+  access.Trustee.ptstrName = reinterpret_cast<LPWSTR>(sid_buffer);
+
+  error = SetEntriesInAclW(1, &access, existing_dacl, &updated_dacl);
+  if (error != ERROR_SUCCESS) {
+    LOG_ERROR("SetEntriesInAclW failed, error={}", error);
+    LocalFree(security_descriptor);
+    return false;
+  }
+
+  error = SetSecurityInfo(service, SE_SERVICE, DACL_SECURITY_INFORMATION,
+                          nullptr, nullptr, updated_dacl, nullptr);
+  if (error != ERROR_SUCCESS) {
+    LOG_ERROR("SetSecurityInfo failed, error={}", error);
+    LocalFree(updated_dacl);
+    LocalFree(security_descriptor);
+    return false;
+  }
+
+  LocalFree(updated_dacl);
+  LocalFree(security_descriptor);
+  return true;
+}
+
 std::string QueryNamedPipeMessage(const std::wstring& pipe_name,
                                   const std::string& command,
                                   DWORD timeout_ms) {
@@ -812,6 +907,10 @@ int CrossDeskServiceHost::InitializeRuntime() {
   RefreshSessionState();
   EnsureSessionHelper();
   ipc_thread_ = std::thread(&CrossDeskServiceHost::IpcServerLoop, this);
+  if (!console_mode_) {
+    client_process_monitor_thread_ =
+        std::thread(&CrossDeskServiceHost::ClientProcessMonitorLoop, this);
+  }
   LOG_INFO("CrossDesk service runtime initialized, session_id={}",
            active_session_id_);
   return 0;
@@ -825,6 +924,10 @@ void CrossDeskServiceHost::ShutdownRuntime() {
     SetEvent(stop_event_);
   }
 
+  if (client_process_monitor_thread_.joinable()) {
+    client_process_monitor_thread_.join();
+  }
+
   if (ipc_thread_.joinable()) {
     ipc_thread_.join();
   }
@@ -841,6 +944,34 @@ void CrossDeskServiceHost::RequestStop() {
   }
 }
 
+void CrossDeskServiceHost::ClientProcessMonitorLoop() {
+  const ULONGLONG monitor_started_at = GetTickCount64();
+
+  while (stop_event_ != nullptr) {
+    DWORD wait_result =
+        WaitForSingleObject(stop_event_, kCrossDeskClientMonitorIntervalMs);
+    if (wait_result == WAIT_OBJECT_0) {
+      return;
+    }
+    if (wait_result != WAIT_TIMEOUT) {
+      continue;
+    }
+
+    if (GetTickCount64() - monitor_started_at <
+        kCrossDeskClientMonitorStartupGraceMs) {
+      continue;
+    }
+
+    if (HasRunningCrossDeskClientProcess()) {
+      continue;
+    }
+
+    LOG_INFO("No crossdesk client process detected, stopping service");
+    RequestStop();
+    return;
+  }
+}
+
 void CrossDeskServiceHost::ReportServiceStatus(DWORD current_state,
                                                DWORD win32_exit_code,
                                                DWORD wait_hint) {
@@ -1845,7 +1976,7 @@ bool InstallCrossDeskService(const std::wstring& binary_path) {
   std::wstring service_command = L"\"" + binary_path + L"\" --service";
   SC_HANDLE service = CreateServiceW(
       manager, kCrossDeskServiceName, kCrossDeskServiceDisplayName,
-      SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START,
+      SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_DEMAND_START,
       SERVICE_ERROR_NORMAL, service_command.c_str(), nullptr, nullptr, nullptr,
       nullptr, nullptr);
 
@@ -1858,14 +1989,15 @@ bool InstallCrossDeskService(const std::wstring& binary_path) {
     }
 
     service = OpenServiceW(manager, kCrossDeskServiceName,
-                           SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS);
+                           SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS |
+                               READ_CONTROL | WRITE_DAC);
     if (service == nullptr) {
       LOG_ERROR("OpenServiceW failed, error={}", GetLastError());
       CloseServiceHandle(manager);
       return false;
     }
 
-    if (!ChangeServiceConfigW(service, SERVICE_NO_CHANGE, SERVICE_AUTO_START,
+    if (!ChangeServiceConfigW(service, SERVICE_NO_CHANGE, SERVICE_DEMAND_START,
                               SERVICE_NO_CHANGE, service_command.c_str(),
                               nullptr, nullptr, nullptr, nullptr, nullptr,
                               kCrossDeskServiceDisplayName)) {
@@ -1876,6 +2008,39 @@ bool InstallCrossDeskService(const std::wstring& binary_path) {
     }
   }
 
+  if (!GrantCrossDeskServiceStartAccessToAuthenticatedUsers(service)) {
+    CloseServiceHandle(service);
+    CloseServiceHandle(manager);
+    return false;
+  }
+
+  CloseServiceHandle(service);
+  CloseServiceHandle(manager);
+  return true;
+}
+
+bool IsCrossDeskServiceInstalled() {
+  SC_HANDLE manager = OpenSCManagerW(nullptr, nullptr, SC_MANAGER_CONNECT);
+  if (manager == nullptr) {
+    LOG_ERROR("OpenSCManagerW failed, error={}", GetLastError());
+    return false;
+  }
+
+  SC_HANDLE service =
+      OpenServiceW(manager, kCrossDeskServiceName, SERVICE_QUERY_STATUS);
+  if (service == nullptr) {
+    DWORD error = GetLastError();
+    CloseServiceHandle(manager);
+    if (error == ERROR_SERVICE_DOES_NOT_EXIST) {
+      return false;
+    }
+    if (error == ERROR_ACCESS_DENIED) {
+      return true;
+    }
+    LOG_ERROR("OpenServiceW failed, error={}", error);
+    return false;
+  }
+
   CloseServiceHandle(service);
   CloseServiceHandle(manager);
   return true;
@@ -1891,7 +2056,10 @@ bool StartCrossDeskService() {
   SC_HANDLE service =
       OpenServiceW(manager, kCrossDeskServiceName, SERVICE_START);
   if (service == nullptr) {
-    LOG_ERROR("OpenServiceW failed, error={}", GetLastError());
+    DWORD error = GetLastError();
+    if (error != ERROR_SERVICE_DOES_NOT_EXIST) {
+      LOG_ERROR("OpenServiceW failed, error={}", error);
+    }
     CloseServiceHandle(manager);
     return false;
   }

src/service/windows/service_host.h

@@ -33,6 +33,7 @@ class CrossDeskServiceHost {
   int InitializeRuntime();
   void ShutdownRuntime();
   void RequestStop();
+  void ClientProcessMonitorLoop();
   void ReportServiceStatus(DWORD current_state, DWORD win32_exit_code,
                            DWORD wait_hint);
   void IpcServerLoop();
@@ -71,6 +72,7 @@ class CrossDeskServiceHost {
   SERVICE_STATUS service_status_{};
   HANDLE stop_event_ = nullptr;
   std::thread ipc_thread_;
+  std::thread client_process_monitor_thread_;
   std::mutex state_mutex_;
   DWORD active_session_id_ = 0xFFFFFFFF;
   DWORD process_session_id_ = 0xFFFFFFFF;
@@ -128,6 +130,7 @@ class CrossDeskServiceHost {
   static CrossDeskServiceHost* instance_;
 };
 
+bool IsCrossDeskServiceInstalled();
 bool InstallCrossDeskService(const std::wstring& binary_path);
 bool UninstallCrossDeskService();
 bool StartCrossDeskService();

xmake/platform.lua

@@ -49,7 +49,7 @@ function setup_platform_settings()
         end
 
         if is_config("USE_WAYLAND", true) then
-            add_links("dbus-1", "pipewire-0.3")
+            add_links("dbus-1")
             add_defines("CROSSDESK_HAS_WAYLAND_CAPTURER=1")
             add_existing_include_dirs({
                 "/usr/include/dbus-1.0",