[fix] keep Windows privacy screen active when running as administrator

[release] prepare v1.5.1 release notes
[fix] refine network stats layout and alignment
2026-10-15 00:09:39 +08:00 · 2026-09-17 09:55:34 +08:00 · 2026-09-17 02:56:49 +08:00 · 2026-09-17 02:45:35 +08:00 · 2026-09-17 02:01:55 +08:00 · 2026-09-17 01:39:09 +08:00
450 changed files with 25879 additions and 7404 deletions
@@ -8,13 +8,15 @@
 # Dependency manifests and local xmake package recipes are the only project
 # files needed while pre-warming the build image.
 !xmake.lua
-!xmake/
-!xmake/**
-!thirdparty/
-!thirdparty/**
-!submodules/
-!submodules/xmake.lua
-!submodules/minirtc/
-!submodules/minirtc/xmake.lua
-!submodules/minirtc/thirdparty/
-!submodules/minirtc/thirdparty/**
+!apps/
+!apps/desktop/
+!apps/desktop/xmake/
+!apps/desktop/xmake/**
+!deps/thirdparty/
+!deps/thirdparty/**
+!deps/submodules/
+!deps/submodules/xmake.lua
+!deps/submodules/minirtc/
+!deps/submodules/minirtc/xmake.lua
+!deps/submodules/minirtc/thirdparty/
+!deps/submodules/minirtc/thirdparty/**
@@ -11,11 +11,11 @@ on:
      - docker/linux-build/**
      - xmake.lua
      - xmake/**
-      - thirdparty/**
-      - submodules/xmake.lua
-      - submodules/minirtc
-      - submodules/minirtc/xmake.lua
-      - submodules/minirtc/thirdparty/**
+      - deps/thirdparty/**
+      - deps/submodules/xmake.lua
+      - deps/submodules/minirtc
+      - deps/submodules/minirtc/xmake.lua
+      - deps/submodules/minirtc/thirdparty/**
  workflow_dispatch:

 permissions:
@@ -36,12 +36,12 @@ jobs:
          - arch: amd64
            runner: ubuntu-24.04
            image: crossdesk/ubuntu20.04:buildenv-cuda12.6.3-gcc10-cmake3.31.6-pipewire0.3.48-xmake3.0.9-rust1.92.0
-            package_script: ./scripts/linux/pkg_amd64.sh
+            package_script: ./apps/desktop/scripts/linux/pkg_amd64.sh

          - arch: arm64
            runner: ubuntu-24.04-arm
            image: crossdesk/ubuntu20.04:buildenv-cuda12.6.3-gcc10-cmake3.31.6-pipewire0.3.48-xmake3.0.9-rust1.92.0
-            package_script: ./scripts/linux/pkg_arm64.sh
+            package_script: ./apps/desktop/scripts/linux/pkg_arm64.sh

    container:
      image: ${{ matrix.image }}
@@ -138,6 +138,17 @@ jobs:
            --cc=gcc-10 --cxx=g++-10 --root -y
          xmake b -vy --root crossdesk

+      - name: Verify repository and wire boundaries
+        env:
+          XMAKE_GLOBALDIR: /data
+        run: |
+          xmake b -vy --root repository_structure_test
+          xmake b -vy --root crossdesk_wire_test
+          xmake b -vy --root keyboard_state_wire_test
+          xmake run --root repository_structure_test
+          xmake run --root crossdesk_wire_test
+          xmake run --root keyboard_state_wire_test
+
      - name: Package
        run: |
          chmod +x ${{ matrix.package_script }}
@@ -178,13 +189,13 @@ jobs:
            runner: macos-26-intel
            cache-key: intel-macos26-xcode26.6-min14
            out-dir: ./build/macosx/x86_64/release/crossdesk
-            package_script: ./scripts/macosx/pkg_x64.sh
+            package_script: ./apps/desktop/scripts/macos/pkg_x64.sh
          - arch: arm64
            binary_arch: arm64
            runner: macos-26
            cache-key: arm-macos26-xcode26.6-min14
            out-dir: ./build/macosx/arm64/release/crossdesk
-            package_script: ./scripts/macosx/pkg_arm64.sh
+            package_script: ./apps/desktop/scripts/macos/pkg_arm64.sh

    steps:
      - name: Extract version number
@@ -260,7 +271,7 @@ jobs:

      - name: Build CrossDesk
        run: |
-          xmake f --target_minver=${MACOSX_DEPLOYMENT_TARGET} --CROSSDESK_VERSION=${VERSION_NUM} --USE_CUDA=false -y
+          xmake f --target_minver=${MACOSX_DEPLOYMENT_TARGET} --CROSSDESK_VERSION=${VERSION_NUM} --USE_CUDA=false -vyD
          xmake b -vy crossdesk

      - name: Package CrossDesk app
@@ -282,7 +293,7 @@ jobs:
            exit 1
          fi

-          ./scripts/macosx/verify_app.sh "${APP_PATH}" "${{ matrix.binary_arch }}" "${EXPECTED_MACOS_SDK}"
+          ./apps/desktop/scripts/macos/verify_app.sh "${APP_PATH}" "${{ matrix.binary_arch }}" "${EXPECTED_MACOS_SDK}"

      - name: Upload build artifacts
        uses: actions/upload-artifact@v6
@@ -295,6 +306,200 @@ jobs:
          mkdir -p release
          cp crossdesk-macos-${{ matrix.arch }}-${{ env.VERSION_NUM }}.pkg release/

+  # iOS
+  build-ios:
+    name: Build on iOS (arm64)
+    runs-on: macos-26
+    timeout-minutes: 120
+    outputs:
+      version: ${{ steps.ios_version.outputs.version }}
+    env:
+      IOS_DEPLOYMENT_TARGET: "16.0"
+      EXPECTED_IOS_SDK: "26.5"
+      XMAKE_VERSION: "3.1.1"
+      XMAKE_REPO_REVISION: "121109352da272cd1a3d4ed52f2dcda34f839955"
+
+    steps:
+      - name: Extract version number
+        shell: bash
+        run: |
+          VERSION_REF="${GITHUB_REF##*/}"
+          VERSION_BASE="${VERSION_REF#v}"
+          BUILD_DATE=$(TZ=Asia/Shanghai date +%Y%m%d)
+          PATCH_NUMBER="${{ github.event.inputs.patch }}"
+
+          if [[ ! "${PATCH_NUMBER}" =~ ^[0-9]+$ ]]; then
+            PATCH_NUMBER=0
+          fi
+
+          if [[ "${VERSION_BASE}" =~ ^([0-9]+(\.[0-9]+){1,3})-([0-9]+)-([0-9]{8})$ ]]; then
+            VERSION_BASE="${BASH_REMATCH[1]}"
+            PATCH_NUMBER="${BASH_REMATCH[3]}"
+            BUILD_DATE="${BASH_REMATCH[4]}"
+          elif [[ "${VERSION_BASE}" =~ ^([0-9]+(\.[0-9]+){1,3})-([0-9]{8})-([0-9]+)$ ]]; then
+            VERSION_BASE="${BASH_REMATCH[1]}"
+            BUILD_DATE="${BASH_REMATCH[3]}"
+            PATCH_NUMBER="${BASH_REMATCH[4]}"
+          elif [[ "${VERSION_BASE}" =~ ^([0-9]+(\.[0-9]+){1,3})-([0-9]{8})$ ]]; then
+            VERSION_BASE="${BASH_REMATCH[1]}"
+            BUILD_DATE="${BASH_REMATCH[3]}"
+          elif [[ "${VERSION_BASE}" =~ ^([0-9]+(\.[0-9]+){1,3})-([0-9]+)$ && "${PATCH_NUMBER}" == "0" ]]; then
+            VERSION_BASE="${BASH_REMATCH[1]}"
+            PATCH_NUMBER="${BASH_REMATCH[3]}"
+          fi
+
+          if [[ "${PATCH_NUMBER}" != "0" ]]; then
+            VERSION_NUM="v${VERSION_BASE}-${PATCH_NUMBER}-${BUILD_DATE}"
+          else
+            VERSION_NUM="v${VERSION_BASE}-${BUILD_DATE}"
+          fi
+
+          echo "VERSION_NUM=${VERSION_NUM}" >> "${GITHUB_ENV}"
+          echo "VERSION_NUM=${VERSION_NUM}"
+
+      - name: Select Xcode 26.6
+        shell: bash
+        run: |
+          sudo xcode-select -s /Applications/Xcode_26.6.app/Contents/Developer
+          xcodebuild -version
+          SDK_VERSION="$(xcrun --sdk iphoneos --show-sdk-version)"
+          if [[ "${SDK_VERSION}" != "${EXPECTED_IOS_SDK}" ]]; then
+            echo "Unexpected iOS SDK: expected ${EXPECTED_IOS_SDK}, got ${SDK_VERSION}" >&2
+            exit 1
+          fi
+
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Read independent iOS version
+        id: ios_version
+        shell: bash
+        run: |
+          IOS_VERSION_BASE="$(xcodebuild \
+            -project apps/ios/CrossDeskMobile.xcodeproj \
+            -scheme CrossDeskMobile \
+            -configuration Release \
+            -destination 'generic/platform=iOS' \
+            -showBuildSettings CODE_SIGNING_ALLOWED=NO | \
+            awk '$1 == "MARKETING_VERSION" && $2 == "=" { print $3 }')"
+          if [[ ! "${IOS_VERSION_BASE}" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "Invalid iOS marketing version: ${IOS_VERSION_BASE}" >&2
+            exit 1
+          fi
+          VERSION_NUM="v${IOS_VERSION_BASE}-${VERSION_NUM##*-}"
+          echo "IOS_VERSION_BASE=${IOS_VERSION_BASE}" >> "${GITHUB_ENV}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> "${GITHUB_ENV}"
+          echo "version=${VERSION_NUM}" >> "${GITHUB_OUTPUT}"
+
+      - name: Initialize submodules
+        run: git submodule update --init --recursive
+
+      - name: Cache xmake dependencies
+        uses: actions/cache@v5
+        with:
+          path: apps/ios/.xmake/packages
+          key: "${{ runner.os }}-xmake${{ env.XMAKE_VERSION }}-deps-ios-arm64-xcode26.6-xrepo1211093-min16-${{ github.run_id }}"
+          restore-keys: |
+            ${{ runner.os }}-xmake${{ env.XMAKE_VERSION }}-deps-ios-arm64-xcode26.6-xrepo1211093-min16-
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+
+      - name: Install xmake
+        uses: xmake-io/github-action-setup-xmake@v1
+        with:
+          xmake-version: "${{ env.XMAKE_VERSION }}"
+
+      - name: Verify xmake version
+        shell: bash
+        run: |
+          XMAKE_VERSION_OUTPUT="$(xmake --version)"
+          echo "${XMAKE_VERSION_OUTPUT}"
+          if [[ "${XMAKE_VERSION_OUTPUT}" != *"xmake v${XMAKE_VERSION}"* ]]; then
+            echo "Unexpected xmake version: expected ${XMAKE_VERSION}" >&2
+            exit 1
+          fi
+
+      - name: Pin xmake package repository
+        shell: bash
+        run: |
+          xmake repo -u
+          XMAKE_REPO_DIR="${HOME}/.xmake/repositories/xmake-repo"
+          git -C "${XMAKE_REPO_DIR}" fetch --depth=1 origin "${XMAKE_REPO_REVISION}"
+          git -C "${XMAKE_REPO_DIR}" checkout --detach "${XMAKE_REPO_REVISION}"
+          test "$(git -C "${XMAKE_REPO_DIR}" rev-parse HEAD)" = "${XMAKE_REPO_REVISION}"
+
+      - name: Build CrossDesk Mobile
+        shell: bash
+        run: |
+          DERIVED_DATA="${RUNNER_TEMP}/CrossDeskMobileDerivedData"
+          echo "DERIVED_DATA=${DERIVED_DATA}" >> "${GITHUB_ENV}"
+          xcodebuild \
+            -project apps/ios/CrossDeskMobile.xcodeproj \
+            -scheme CrossDeskMobile \
+            -configuration Release \
+            -destination 'generic/platform=iOS' \
+            -derivedDataPath "${DERIVED_DATA}" \
+            CODE_SIGNING_ALLOWED=NO \
+            CODE_SIGNING_REQUIRED=NO \
+            COMPILER_INDEX_STORE_ENABLE=NO \
+            IPHONEOS_DEPLOYMENT_TARGET="${IOS_DEPLOYMENT_TARGET}" \
+            build
+
+      - name: Verify CrossDesk Mobile
+        shell: bash
+        run: |
+          APP_PATH="${DERIVED_DATA}/Build/Products/Release-iphoneos/CrossDeskMobile.app"
+          EXECUTABLE_PATH="${APP_PATH}/CrossDeskMobile"
+          INFO_PLIST="${APP_PATH}/Info.plist"
+
+          if [[ ! -x "${EXECUTABLE_PATH}" ]]; then
+            echo "CrossDeskMobile executable is missing from ${APP_PATH}" >&2
+            exit 1
+          fi
+
+          xcrun lipo "${EXECUTABLE_PATH}" -verify_arch arm64
+          APP_VERSION=$(/usr/libexec/PlistBuddy -c 'Print :CFBundleShortVersionString' "${INFO_PLIST}")
+          if [[ "${APP_VERSION}" != "${IOS_VERSION_BASE}" ]]; then
+            echo "Unexpected iOS app version: expected ${IOS_VERSION_BASE}, got ${APP_VERSION}" >&2
+            exit 1
+          fi
+          MINIMUM_OS=$(/usr/libexec/PlistBuddy -c 'Print :MinimumOSVersion' "${INFO_PLIST}")
+          if [[ "${MINIMUM_OS}" != "${IOS_DEPLOYMENT_TARGET}" ]]; then
+            echo "Unexpected minimum iOS version: expected ${IOS_DEPLOYMENT_TARGET}, got ${MINIMUM_OS}" >&2
+            exit 1
+          fi
+
+          xcrun lipo -info "${EXECUTABLE_PATH}"
+          echo "Minimum iOS version: ${MINIMUM_OS}"
+
+      - name: Package CrossDesk Mobile
+        shell: bash
+        run: |
+          APP_PATH="${DERIVED_DATA}/Build/Products/Release-iphoneos/CrossDeskMobile.app"
+          PACKAGE_DIR="${RUNNER_TEMP}/crossdesk-ios-arm64-unsigned-${VERSION_NUM}"
+          PACKAGE_FILE="${GITHUB_WORKSPACE}/crossdesk-ios-arm64-unsigned-${VERSION_NUM}.zip"
+
+          mkdir -p "${PACKAGE_DIR}"
+          cp -R "${APP_PATH}" "${PACKAGE_DIR}/"
+
+          DSYM_PATH="${DERIVED_DATA}/Build/Products/Release-iphoneos/CrossDeskMobile.app.dSYM"
+          if [[ -d "${DSYM_PATH}" ]]; then
+            cp -R "${DSYM_PATH}" "${PACKAGE_DIR}/"
+          fi
+
+          ditto -c -k --sequesterRsrc --keepParent "${PACKAGE_DIR}" "${PACKAGE_FILE}"
+          echo "PACKAGE_FILE=${PACKAGE_FILE}" >> "${GITHUB_ENV}"
+
+      - name: Upload build artifact
+        uses: actions/upload-artifact@v6
+        with:
+          name: crossdesk-ios-arm64-unsigned-${{ env.VERSION_NUM }}
+          path: ${{ env.PACKAGE_FILE }}
+          if-no-files-found: error
+
  # Windows
  build-windows-x64:
    name: Build on Windows x64
@@ -404,7 +609,7 @@ jobs:
      - name: Copy nsProcess plugin to NSIS folder
        run: |
          $nsisPluginDir = "C:\Program Files (x86)\NSIS\Plugins\x86-unicode"
-          copy "${{ github.workspace }}\scripts\windows\nsProcess.dll" $nsisPluginDir
+          copy "${{ github.workspace }}\apps\desktop\scripts\windows\nsProcess.dll" $nsisPluginDir

      - name: Build CrossDesk
        run: |
@@ -414,14 +619,14 @@ jobs:
      - name: Package
        shell: pwsh
        run: |
-          & "${{ github.workspace }}\scripts\windows\pkg_x64.ps1" $env:VERSION_NUM
+          & "${{ github.workspace }}\apps\desktop\scripts\windows\pkg_x64.ps1" $env:VERSION_NUM

      - name: Upload unsigned Windows installer for test signing
        if: github.event_name == 'workflow_dispatch' && inputs.sign_windows_test
        id: upload-unsigned-windows-installer
        uses: actions/upload-artifact@v7
        with:
-          path: ${{ github.workspace }}/scripts/windows/crossdesk-win-x64-${{ env.VERSION_NUM }}.exe
+          path: ${{ github.workspace }}/apps/desktop/scripts/windows/crossdesk-win-x64-${{ env.VERSION_NUM }}.exe
          archive: false
          if-no-files-found: error
          retention-days: 1
@@ -447,7 +652,7 @@ jobs:
        run: |
          $installerName = "crossdesk-win-x64-${{ env.VERSION_NUM }}.exe"
          $signedInstaller = Join-Path "${{ github.workspace }}\signpath\signed-installer" $installerName
-          $destination = Join-Path "${{ github.workspace }}\scripts\windows" $installerName
+          $destination = Join-Path "${{ github.workspace }}\apps\desktop\scripts\windows" $installerName

          if (!(Test-Path $signedInstaller)) {
            throw "SignPath did not return the signed installer: $signedInstaller"
@@ -477,7 +682,9 @@ jobs:
          $portableFiles = @(
            @("crossdesk.exe", "CrossDesk.exe"),
            @("crossdesk_service.exe", "crossdesk_service.exe"),
-            @("crossdesk_session_helper.exe", "crossdesk_session_helper.exe")
+            @("crossdesk_session_helper.exe", "crossdesk_session_helper.exe"),
+            @("crossdesk_privacy_cursor_helper.exe", "crossdesk_privacy_cursor_helper.exe"),
+            @("crossdesk_privacy_window.dll", "crossdesk_privacy_window.dll")
          )

          foreach ($file in $portableFiles) {
@@ -504,7 +711,7 @@ jobs:
        uses: actions/upload-artifact@v6
        with:
          name: crossdesk-win-x64-${{ env.VERSION_NUM }}
-          path: ${{ github.workspace }}/scripts/windows/crossdesk-win-x64-${{ env.VERSION_NUM }}.exe
+          path: ${{ github.workspace }}/apps/desktop/scripts/windows/crossdesk-win-x64-${{ env.VERSION_NUM }}.exe

      - name: Upload portable artifact
        uses: actions/upload-artifact@v6
@@ -515,7 +722,7 @@ jobs:
  release:
    name: Publish Release
    if: startsWith(github.ref, 'refs/tags/v')
-    needs: [build-linux, build-macos, build-windows-x64]
+    needs: [build-linux, build-macos, build-ios, build-windows-x64]
    runs-on: ubuntu-latest

    steps:
@@ -571,6 +778,25 @@ jobs:
          echo "BUILD_DATE_ISO=${BUILD_DATE_ISO}" >> $GITHUB_OUTPUT
          echo "PATCH_NUMBER=${PATCH_NUMBER}" >> $GITHUB_OUTPUT

+      - name: Prepare release notes
+        env:
+          RELEASE_TAG: ${{ steps.version.outputs.VERSION_WITH_V }}
+          VERSION_BASE: ${{ steps.version.outputs.VERSION_BASE }}
+        run: |
+          if [[ -f "docs/releases/${RELEASE_TAG}.md" ]]; then
+            cp "docs/releases/${RELEASE_TAG}.md" release-notes.md
+          elif [[ -f "docs/releases/v${VERSION_BASE}.md" ]]; then
+            cp "docs/releases/v${VERSION_BASE}.md" release-notes.md
+          else
+            cat > release-notes.md << 'EOF'
+          Binary release only. Source code is not included.
+
+          ## Code signing policy
+
+          Free code signing provided by [SignPath.io](https://signpath.io/), certificate by [SignPath Foundation](https://signpath.org/).
+          EOF
+          fi
+
      - name: Rename artifacts
        run: |
          mkdir -p release
@@ -578,6 +804,7 @@ jobs:
          cp artifacts/crossdesk-macos-arm64-${{ steps.version.outputs.VERSION_WITH_V }}/* release/crossdesk-macos-arm64-${{ steps.version.outputs.VERSION_WITH_V }}.pkg
          cp artifacts/crossdesk-linux-amd64-${{ steps.version.outputs.VERSION_WITH_V }}/* release/crossdesk-linux-amd64-${{ steps.version.outputs.VERSION_WITH_V }}.deb
          cp artifacts/crossdesk-linux-arm64-${{ steps.version.outputs.VERSION_WITH_V }}/* release/crossdesk-linux-arm64-${{ steps.version.outputs.VERSION_WITH_V }}.deb
+          cp artifacts/crossdesk-ios-arm64-unsigned-${{ needs.build-ios.outputs.version }}/* release/crossdesk-ios-arm64-unsigned-${{ needs.build-ios.outputs.version }}.zip
          cp artifacts/crossdesk-win-x64-${{ steps.version.outputs.VERSION_WITH_V }}/* release/crossdesk-win-x64-${{ steps.version.outputs.VERSION_WITH_V }}.exe
          cp artifacts/crossdesk-win-x64-portable-${{ steps.version.outputs.VERSION_WITH_V }}/* release/crossdesk-win-x64-portable-${{ steps.version.outputs.VERSION_WITH_V }}.zip

@@ -588,17 +815,13 @@ jobs:
        uses: softprops/action-gh-release@v2
        with:
          tag_name: ${{ steps.version.outputs.VERSION_WITH_V }}
+          target_commitish: ${{ github.sha }}
          name: Release ${{ steps.version.outputs.VERSION_WITH_V }}
          draft: false
          prerelease: false
          files: release/*
          generate_release_notes: false
-          body: |
-            Binary release only. Source code is not included.
-
-            ## Code signing policy
-
-            Free code signing provided by [SignPath.io](https://signpath.io/), certificate by [SignPath Foundation](https://signpath.org/).
+          body_path: release-notes.md

      - name: Create or update 'latest' tag
        run: |
@@ -616,12 +839,7 @@ jobs:
          prerelease: false
          files: release/*
          generate_release_notes: false
-          body: |
-            Binary release only. Source code is not included.
-
-            ## Code signing policy
-
-            Free code signing provided by [SignPath.io](https://signpath.io/), certificate by [SignPath Foundation](https://signpath.org/).
+          body_path: release-notes.md

      - name: Upload artifacts to server
        uses: burnett01/rsync-deployments@5.2
@@ -672,6 +890,11 @@ jobs:
            }
          }
          EOF
+          jq --arg release_name "Release ${{ steps.version.outputs.VERSION_WITH_V }}" \
+            --rawfile release_notes release-notes.md \
+            '.releaseName = $release_name | .releaseNotes = $release_notes' \
+            version.json > version-with-notes.json
+          mv version-with-notes.json version.json
          cat version.json

      - name: Upload version.json to server
@@ -1,9 +1,14 @@
 # Xmake cache
 .xmake/
 build/
+apps/ios/Vendor/
+apps/ios/DerivedData*/
+apps/ios/.xmake/
+xcuserdata/
+*.xcuserstate

 # MacOS Cache
 .DS_Store

 # VSCode cache
-.vscode
+.vscode
@@ -1,3 +1,3 @@
-[submodule "submodules/minirtc"]
-	path = submodules/minirtc
+[submodule "deps/submodules/minirtc"]
+	path = deps/submodules/minirtc
 	url = https://github.com/kunkundi/minirtc.git
@@ -1,429 +1,211 @@
-# CrossDesk
+<div align="center">
+  <img src="apps/desktop/resources/linux/crossdesk_128x128.png" width="80" alt="CrossDesk 标志" />
+  <h1>CrossDesk</h1>
+  <p>轻量、跨平台的远程桌面，让电脑、浏览器和 iPhone / iPad 连接到同一张桌面。</p>
+  <p><a href="https://www.crossdesk.cn/">官方网站</a> · <a href="https://github.com/kunkundi/crossdesk/releases">下载客户端</a> · <a href="https://web.crossdesk.cn/">打开 Web 客户端</a> · <a href="README_EN.md">English</a></p>
+</div>

-<a href="https://hellogithub.com/repository/kunkundi/crossdesk" target="_blank"><img src="https://api.hellogithub.com/v1/widgets/recommend.svg?rid=55d41367570345f1838e02fd12be7961&claim_uid=cb0OpZRrBuGVAfL&theme=small" alt="Featured｜HelloGitHub" /></a>
+<div align="center">

-[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-brightgreen.svg)](https://www.crossdesk.cn/)
-[![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
-[![GitHub last commit](https://img.shields.io/github/last-commit/kunkundi/crossdesk)](https://github.com/kunkundi/crossdesk/commits/web-client)
-[![Build Status](https://github.com/kunkundi/crossdesk/actions/workflows/build.yml/badge.svg)](https://github.com/kunkundi/crossdesk/actions)  
-[![Docker Pulls](https://img.shields.io/docker/pulls/crossdesk/crossdesk-server)](https://hub.docker.com/r/crossdesk/crossdesk-server/tags)
-[![GitHub issues](https://img.shields.io/github/issues/kunkundi/crossdesk.svg)](https://github.com/kunkundi/crossdesk/issues)
-[![GitHub stars](https://img.shields.io/github/stars/kunkundi/crossdesk.svg?style=social)](https://github.com/kunkundi/crossdesk/stargazers)
-[![GitHub forks](https://img.shields.io/github/forks/kunkundi/crossdesk.svg?style=social)](https://github.com/kunkundi/crossdesk/forks)
+[![Platforms](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux%20%7C%20iOS-blue)](#download)
+[![Release](https://img.shields.io/github/v/release/kunkundi/crossdesk)](https://github.com/kunkundi/crossdesk/releases)
+[![Build](https://github.com/kunkundi/crossdesk/actions/workflows/build.yml/badge.svg)](https://github.com/kunkundi/crossdesk/actions/workflows/build.yml)
+[![License: GPL v3](https://img.shields.io/badge/license-GPL--3.0-blue)](LICENSE)
+[![Stars](https://img.shields.io/github/stars/kunkundi/crossdesk?style=social)](https://github.com/kunkundi/crossdesk/stargazers)

-[ [English](README_EN.md) / 中文 ]
+</div>

---
+CrossDesk 支持 Windows、macOS、Linux 之间的远程访问，也可从浏览器或原生 iOS 客户端控制电脑。项目基于 [MiniRTC](https://github.com/kunkundi/minirtc)，提供实时音视频传输、键鼠控制、文件传输与自托管能力，仍在持续开发中。
+
+> 本文按当前仓库代码整理。截图展示当前 Slint 桌面界面，使用演示 ID、密码、在线状态和连接记录；缩略图来自公开页面；下载包的功能与系统要求请同时核对对应 Release 说明。原生 iOS 客户端的构建、签名方式见下文。
+
+[界面预览](#preview) · [下载与安装](#download) · [快速连接](#quick-start) · [会话操作](#session) · [设置](#settings) · [iOS](#ios) · [自托管](#self-hosting) · [源码构建](docs/BUILD.md) · [常见问题](docs/FAQ.md)
+
+<a id="preview"></a>

 ## 界面预览

-### PC 客户端
+### 桌面客户端

-![sup_example](https://github.com/user-attachments/assets/eeb64fbe-1f07-4626-be1c-b77396beb905)
+主窗口集中展示本机 ID、连接密码、远程连接入口和近期连接记录。
+
+<p align="center">
+  <img src="docs/images/desktop-main-zh.png" width="800" alt="当前桌面客户端示例：已连接服务器，三台在线设备均显示页面缩略图" />
+</p>

 ### Web 客户端

+在浏览器中输入远程设备 ID 和密码，无需在控制端安装桌面客户端。
+
 <p align="center">
-  <img width="850" height="550" alt="6bddcbed47ffd4b9988a4037c7f4f524" src="https://github.com/user-attachments/assets/e44f73f9-24ac-46a3-a189-b7f8b6669881" />
+  <img src="docs/images/web-client.png" width="800" alt="CrossDesk Web 客户端当前连接首页" />
 </p>

---
+图片来源与更新方式见 [截图说明](docs/images/README.md)。

-## 简介
+## 主要功能

-CrossDesk 是一个轻量级的跨平台远程桌面软件，支持 Web 端控制远程设备。
-
-CrossDesk 是 [MiniRTC](https://github.com/kunkundi/minirtc.git) 实时音视频传输库的实验性应用。MiniRTC 是一个轻量级的跨平台实时音视频传输库。它具有网络透传（[RFC5245](https://datatracker.ietf.org/doc/html/rfc5245)），视频软硬编解码（H264/AV1），音频编解码（[Opus](https://github.com/xiph/opus)），信令交互，网络拥塞控制，传输加密（[SRTP](https://tools.ietf.org/html/rfc3711)）等基础能力。
-
---
-
-## 系统要求
-
-| 平台 | 最低版本 |
+| 能力 | 当前支持 |
 | --- | --- |
-| **Windows** | Windows 10 及以上 (64 位) |
-| **macOS** | macOS Intel 15.0 及以上 ( 大于 14.0 小于 15.0 的版本可自行编译实现兼容 )<br> macOS Apple Silicon 14.0 及以上 |
-| **Linux** | Ubuntu 20.04 及以上 |
+| 跨平台控制 | Windows / macOS / Linux 桌面互控；浏览器与原生 iOS 作为控制端 |
+| 实时画面与声音 | H.264 / AV1、30 / 60 fps 设置、硬件编解码选项、远端声音播放；实际能力取决于设备与构建配置 |
+| 多设备与多显示器 | 近期连接、设备别名、会话标签与远端显示器切换 |
+| 输入与协作 | 键鼠输入、远端光标同步、组合键、文本剪贴板同步、文件传输 |
+| 网络与部署 | P2P 直连、TURN 中继、SRTP 加密选项、自托管信令与中继服务 |
+| Windows 锁屏控制 | 通过 CrossDesk Service 支持锁屏、登录界面及安全桌面的输入转发 |

---
+各客户端的入口和能力有所不同；桌面会话操作见下文，iOS 的具体功能见 [开发说明](apps/ios/README.md)。

-## 使用
+<a id="download"></a>

-在菜单栏“对端ID”处输入远端桌面的ID，点击“→”即可发起远程连接。
+## 下载与安装

-![usage1](https://github.com/user-attachments/assets/3a4bb59f-c84c-44d2-9a20-11790aac510e)
+前往 [GitHub Releases](https://github.com/kunkundi/crossdesk/releases) 或 [官方网站](https://www.crossdesk.cn/)，按系统与 CPU 架构选择安装包。

-如果远端桌面设置了连接密码，则本端需填写正确的连接密码才能成功发起远程连接。
+| 平台 | 当前源码 / CI 基线 | 安装方式 |
+| --- | --- | --- |
+| Windows | Windows 10+，x64 | `.exe` 安装包；便携构建也受支持 |
+| macOS | macOS 14.0+，Intel / Apple Silicon | 选择 x64 或 arm64 的 `.pkg` |
+| Linux | Ubuntu 20.04+，amd64 / arm64，glibc 2.31 基线 | `.deb` 安装包 |
+| iOS / iPadOS | iOS 16.0+，arm64 真机 | 原生客户端；使用 Xcode 构建并签名，CI 产物为未签名应用 |
+| Web | 支持 WebRTC 的浏览器 | 访问 [web.crossdesk.cn](https://web.crossdesk.cn/) |

-![password](https://github.com/user-attachments/assets/1beadcce-640d-4f5c-8e77-51917b5294d5)
+Linux 下载后，在下载目录中将文件名替换为实际安装包名称：

-发起连接前，可在设置中自定义配置项，如语言、视频编码格式等。
-![settings](https://github.com/user-attachments/assets/8bc5468d-7bbb-4e30-95bd-da1f352ac08c)
+```bash
+sudo apt install "./crossdesk-linux-amd64-<version>.deb"
+```

-### 使用 Web 客户端
+**macOS 首次运行：** 按应用提示，在“系统设置 → 隐私与安全性”中授予 CrossDesk **屏幕录制**（新系统可能显示为“屏幕与系统音频录制”）及 **辅助功能**权限，再按系统提示重新打开应用。前者用于捕获桌面，后者用于远程键鼠输入。

-浏览器访问 [CrossDesk Web Client](https://web.crossdesk.cn/)。
-输入 **远程设备 ID** 与 **密码**，点击连接即可接入远程设备。如图，**iOS Safari 远程控制 Win11**：
+<a id="quick-start"></a>

-<img width="645" height="300" alt="_cgi-bin_mmwebwx-bin_webwxgetmsgimg__ MsgID=932911462648581698 skey=@crypt_1f5153b1_b550ca7462b5009ce03c991cca2a92a7 mmweb_appid=wx_webfilehelper" src="https://github.com/user-attachments/assets/a5109e6f-752c-4654-9f4e-7e161bddf43e" />
+## 快速连接

-### Windows 服务（CrossDesk Service）
+### 从另一台电脑连接

-CrossDesk 在 Windows 平台提供本地辅助服务 **CrossDesk Service**，服务名为 `CrossDeskService`。该服务用于锁屏、登录界面和安全桌面等受保护场景下的远程控制增强能力，包括：
+1. **准备被控电脑。** 安装并运行 CrossDesk，等待底部显示“已连接服务器”。在左侧“本桌面”查看 **本机 ID** 和 **密码**，提供给控制端。
+2. **输入对端 ID。** 在控制端右侧“远程桌面 → 对端 ID”输入被控电脑的 ID，点击 **→**。
+3. **完成密码验证。** 按弹窗输入被控电脑当前的连接密码，确认后等待远程画面出现。需要保存密码时勾选“记住密码”。
+4. **再次连接。** 成功连接过的设备会出现在“近期连接”中，可通过卡片重连，也可编辑别名或删除记录。

- 上报远端当前是否处于锁屏、登录、凭据输入或安全桌面状态；
- 支持从控制端发送 `Ctrl+Alt+Del`（SAS）；
- 在锁屏、登录和安全桌面阶段转发键盘、鼠标输入。
+本机密码旁的眼睛按钮用于显示 / 隐藏密码，铅笔按钮用于修改密码。修改时使用 **6 位数字或英文字母**，并保持连接服务器；等待修改成功、客户端重新连接后，再复制当前密码。已保存旧密码的控制端需重新输入。

-Windows 安装包会自动打包 `crossdesk_service.exe` 和 `crossdesk_session_helper.exe`，并在安装时注册为按需启动的 Windows 服务。CrossDesk 客户端启动时会尝试启动已安装的服务；当本机没有 CrossDesk 客户端进程运行时，服务会自动退出。卸载客户端时会同步停止并移除该服务。
+### 从浏览器连接

-如果是手动编译或手动部署 Windows 版本，请确保 `CrossDesk.exe`、`crossdesk_service.exe` 和 `crossdesk_session_helper.exe` 位于同一目录。安装或卸载服务需要使用管理员权限打开 PowerShell：
+1. 保持被控电脑上的 CrossDesk 运行，并确认已连接服务器；在被控端“设置”中保持 **启用 SRTP** 开启。
+2. 打开 [Web 客户端](https://web.crossdesk.cn/)，输入 **远程设备 ID** 和 **密码**，点击“连接”。
+3. 连接后使用页面提供的显示器、鼠标模式和键盘控件操作远端；手机和平板也可通过浏览器访问。
+
+如果使用自建服务器，需要让控制端与被控端接入同一服务；Web 部署配置见 [CrossDesk Web Client](https://github.com/kunkundi/crossdesk-web-client)。
+
+<a id="session"></a>
+
+## 会话中的常用操作
+
+远程窗口通过会话标签切换设备，控制栏提供以下操作；控制栏收起时先点击展开按钮。将鼠标悬停在图标上可查看提示。
+
+| 入口 | 用途 |
+| --- | --- |
+| 显示器 | 切换远端显示器 |
+| 键盘 | 发送组合键；Windows 的 `Ctrl+Alt+Del` 依赖远端服务 |
+| 鼠标 | 控制 / 释放远端鼠标 |
+| 扬声器 | 播放声音 / 静音 |
+| 文件夹 | 选择文件发送到远端，并查看传输进度 |
+| 网络状态 | 查看流量、丢包率、帧率、分辨率及直连 / 中继状态 |
+| 全屏 | 进入 / 退出全屏 |
+| 断开连接 | 结束当前远程会话 |
+
+桌面端可同步文本剪贴板。接收文件的位置可在“设置 → 文件保存路径”调整。关闭主窗口会隐藏窗口并保持程序运行；需要完全退出时使用系统托盘或菜单栏中的退出入口。
+
+<a id="settings"></a>
+
+## 调整画面与连接设置
+
+点击主窗口右上角 **☰ → 设置**，修改后点击“确认”保存。建议在建立连接前调整；会话进行中部分选项不可修改。设置列表可向下滚动，查看自托管、启动方式与文件保存路径。
+
+<p align="center">
+  <img src="docs/images/desktop-settings-zh.png" width="720" alt="当前设置界面：画质、帧率、画面偏好、编解码、中继与 SRTP" />
+</p>
+
+| 设置 | 说明 |
+| --- | --- |
+| 画面质量 / 帧率 | 选择低、中、高画质与 30 / 60 fps；实际帧率取决于网络和设备 |
+| 画面偏好 | 在帧率优先、画质优先、平衡之间选择 |
+| 视频编码格式 | H.264 / AV1；硬件编解码是否可用取决于平台、硬件与构建选项 |
+| 启用中继服务 | 允许借助 TURN 中继建立连接；P2P 连接失败时先检查此项 |
+| 启用 SRTP | 媒体传输加密选项，两端配置需兼容 |
+| 自托管配置 | 设置服务器地址、信令端口与中继端口，并勾选启用 |
+| 开机自启 / 启用守护进程 | 调整启动与进程守护行为，按界面提示重启后生效 |
+| 文件保存路径 | 选择接收文件的目录 |
+
+<a id="ios"></a>
+
+## 原生 iOS / iPadOS 客户端
+
+仓库的 [`apps/ios`](apps/ios/README.md) 提供原生控制端，与桌面端使用同一套 MiniRTC 协议。它可以控制远端电脑；当前不提供将 iPhone / iPad 作为被控桌面的功能。
+
+1. 按 [iOS 开发说明](apps/ios/README.md) 使用 Xcode 构建并签名，安装到 iOS 16+ 的真机。
+2. 在首页输入对端 ID，点击连接并填写密码；成功连接后可从“最近连接”中重连。
+3. 在设置中选择鼠标模式：**相对位置**像触控板一样移动光标，**绝对位置**将触摸位置直接映射到远端画面。
+4. 点击悬浮图标展开菜单，可切换显示器、显示键盘、控制声音或发送文件。收到的文件位于应用的 `Documents/Received`，可通过传输状态旁的分享按钮导出。
+
+当前支持接收远端文本到 iOS 剪贴板；界面暂未提供主动发送本机剪贴板的按钮。
+
+当前支持单指点击、双指右键、长按拖动与捏合缩放；缩放后的双指平移用于移动视图。原生端与浏览器端分别维护，使用入口和手势可能不同。
+
+<a id="windows-service"></a>
+
+## Windows 锁屏与登录界面
+
+**CrossDesk Service**（服务名 `CrossDeskService`）提供锁屏、登录、凭据输入及安全桌面的状态上报、`Ctrl+Alt+Del` 发送和键鼠输入转发。
+
+安装版会注册按需启动的服务，客户端启动时尝试启动它；本机没有 CrossDesk 客户端进程后服务会自动退出。便携版可在提示窗口或“设置 → 锁屏控制服务”中安装服务，需要管理员权限。该服务依赖客户端运行。
+
+<details>
+<summary>手动部署与服务管理命令</summary>
+
+保留完整安装目录；自行部署构建产物时，将 `CrossDesk.exe`、`crossdesk_service.exe`、`crossdesk_session_helper.exe` 及同次构建输出的全部 `.dll` 放在同一目录。在该目录打开管理员 PowerShell，按需执行：

 ```powershell
-# 安装
 .\CrossDesk.exe --service-install
-# 启动
 .\CrossDesk.exe --service-start
-# 查看状态
 .\CrossDesk.exe --service-status
-# 停止
+.\CrossDesk.exe --service-ping
+# 停止或卸载服务
 .\CrossDesk.exe --service-stop
-# 卸载
 .\CrossDesk.exe --service-uninstall
 ```

-如果远端 Windows 服务未安装、未启动或暂时不可用，基础远程桌面连接仍可使用，但锁屏、登录界面和安全桌面阶段的控制能力会受限，客户端会提示“远端Windows服务不可用”。
+</details>

---
+出现“远端 Windows 服务不可用”时，检查被控电脑的安装和服务状态；普通桌面连接仍可使用，受保护界面的控制能力会受限。

-## 如何编译
-
-### 构建依赖
-
- [xmake](https://xmake.io/#/guide/installation)
- [cmake](https://cmake.org/download/) 3.21 及以上（系统版本过低时由 xmake 自动安装）
-
-### Linux
-
-Linux 构建支持 Ubuntu 20.04 及以上版本的 amd64 和 arm64。发布安装包以
-Ubuntu 20.04/glibc 2.31 为兼容基线。先安装基础编译依赖：
-
-```bash
-sudo apt-get update
-sudo apt-get install -y \
-  git curl unzip build-essential gcc-10 g++-10 python3-pip \
-  pkg-config binutils dpkg-dev \
-  libx11-dev libxext-dev libxrender-dev libxft-dev libxrandr-dev \
-  libxinerama-dev libxcursor-dev libxi-dev libxfixes-dev libxv-dev \
-  libxtst-dev libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev \
-  libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxcb-shm0-dev \
-  libasound2-dev libsndio-dev libpulse-dev \
-  libgl1-mesa-dev
-```
-
-Ubuntu 20.04 自带的 CMake 3.16 不满足要求时，xmake 会自动下载并使用
-CMake 3.21 或更高版本，无需手动替换系统 CMake。
-
-Ubuntu 20.04 默认的 GCC 9 缺少 Slint C++ API 所需的部分 C++20 标准库，
-因此上述命令同时安装并在后续配置中指定 GCC 10。
-
-需要启用 Wayland 捕获或 DRM 捕获时，再安装对应依赖：
-
-```bash
-sudo apt-get install -y libdbus-1-dev libdrm-dev
-
-# Ubuntu 22.04 及以上也可以直接安装系统开发包
-# sudo apt-get install -y libpipewire-0.3-dev libspa-0.2-dev
-```
-
-下载子模块并编译 Release 版本：
-
-```bash
-git clone --recurse-submodules https://github.com/kunkundi/crossdesk.git
-cd crossdesk
-
-# 已经克隆过仓库时执行这一行
-git submodule update --init --recursive
-
-# Ubuntu 20.04 没有 PipeWire 0.3 开发包，安装仅用于编译的头文件 SDK。
-# 已安装发行版 PipeWire 0.3 开发包时可跳过此步骤。
-sudo ./docker/linux-build/install-pipewire-sdk.sh
-
-xmake f -c -m release --USE_CUDA=false --toolchain=gcc-10 -y
-xmake b -vy crossdesk
-```
-
-这里应使用 `--toolchain=gcc-10`，以确保 CrossDesk 及 xmake 在配置阶段构建的
-libyuv 等第三方包都使用 GCC 10。只指定 `--cc`/`--cxx` 时，依赖安装可能仍回退到
-系统默认的 `/bin/cc` 和 `/bin/c++`。`-c` 会清除旧配置，切换编译器时必须保留。
-
-amd64 构建结果位于 `build/linux/x86_64/release/crossdesk`，arm64 构建结果位于 `build/linux/arm64/release/crossdesk`。
-
-启用 Wayland 和 DRM 的配置示例：
-
-```bash
-xmake f -c -m release --USE_WAYLAND=true --USE_DRM=true --USE_CUDA=false \
-  --toolchain=gcc-10 -y
-xmake b -vy crossdesk
-```
-
-生成 Debian 安装包（必须在对应架构上先完成 Release 编译）：
-
-```bash
-# amd64
-./scripts/linux/pkg_amd64.sh 1.0.0
-
-# arm64
-./scripts/linux/pkg_arm64.sh 1.0.0
-```
-
-打包脚本会将 Slint 共享运行库安装到软件包私有目录 `/usr/lib/crossdesk`，无需用户另外安装 `libslint_cpp.so`。
-PipeWire 不属于强制运行时依赖：程序在运行时检测宿主系统的 PipeWire 0.3，
-没有该运行库时仍可使用 X11（以及构建时启用的 DRM）捕获。
-
-### 通用编译选项
-
-```text
--USE_CUDA=true/false: 启用 CUDA 硬件编解码，默认不启用
--USE_WAYLAND=true/false: 在 Linux 上启用 Wayland/PipeWire 捕获，默认不启用
--USE_DRM=true/false: 在 Linux 上启用 DRM 捕获，默认不启用
--CROSSDESK_PORTABLE=true/false: 构建便携版本，默认不启用
--CROSSDESK_VERSION=xxx: 指定 CrossDesk 的版本
-
-# 示例
-xmake f --CROSSDESK_VERSION=1.0.0 --USE_CUDA=true
-```
-
-运行：
-
-```bash
-xmake r crossdesk
-```
-
-### 无 CUDA 环境下的开发支持
-
-对于**未安装 CUDA 环境的 Linux 开发者，如果希望编译后的成果物拥有硬件编解码能力**，这里提供了预配置的 [Ubuntu 20.04 兼容构建镜像](https://hub.docker.com/r/crossdesk/ubuntu20.04)。该镜像内置必要的构建依赖，可生成兼容 glibc 2.31 的单一 Linux 安装包。
-
-进入容器，下载工程后执行：
-
-```bash
-export CUDA_PATH=/usr/local/cuda
-export XMAKE_GLOBALDIR=/data
-
-xmake f --USE_CUDA=true
-xmake b --root -vy crossdesk
-```
-
-对于**未安装 CUDA 环境的 Windows 开发者**，执行下面的命令安装 CUDA 编译环境：
-
-```powershell
-xmake require -vy "cuda 12.6.3"
-```
-
-安装完成后执行:
-
-```powershell
-xmake require --info "cuda 12.6.3"
-```
-
-输出如下:
-
-<img width="860" height="226" alt="Image" src="https://github.com/user-attachments/assets/999ac365-581a-4b9a-806e-05eb3e4cf44d" />
-
-根据上述输出获取到 CUDA 的安装目录，即 installdir 指向的位置。将 CUDA_PATH 加入系统环境变量，或在终端中输入：
-
-```powershell
-set CUDA_PATH=path_to_cuda_installdir
-```
-
-重新执行：
-
-```powershell
-xmake f --USE_CUDA=true
-xmake b -vy crossdesk
-```
-
-#### 注意
-
-运行时如果客户端状态栏显示 **未连接服务器**，请先在 [CrossDesk 官方网站](https://www.crossdesk.cn/) 安装客户端，以便在环境中安装所需的证书文件。
-
-<img width="256" height="120" alt="image" src="https://github.com/user-attachments/assets/1812f7d6-516b-4b4f-8a3d-98bee505cc5a" />
-
-### 关于 Xmake
-
-#### 安装 Xmake
-
-使用 curl：
-
-```bash
-curl -fsSL https://xmake.io/shget.text | bash
-```
-
-使用 wget：
-
-```bash
-wget https://xmake.io/shget.text -O - | bash
-```
-
-使用 powershell：
-
-```powershell
-irm https://xmake.io/psget.text | iex
-```
-
-#### 编译选项
-
-```text
-# 切换编译模式
-xmake f -m debug/release
-
-# 可选编译参数
-r ：重新构建目标
-v ：显示详细的构建日志
-y ：自动确认提示
-
-# 示例
-xmake b -vy crossdesk
-```
-
-#### 运行选项
-
-```bash
-# 使用调试模式运行
-xmake r -d crossdesk
-```
-
-更多使用方法可参考 [Xmake 官方文档](https://xmake.io/guide/quick-start.html)。
-
---
+<a id="self-hosting"></a>

 ## 自托管服务器

-### 服务端
+可自行部署信令服务与 TURN 中继，并在桌面客户端 **☰ → 设置 → 自托管配置** 中填写连接信息。控制端与被控端都需要启用同一套配置。

-推荐使用 Docker 部署 CrossDesk Server。
+- [自托管指南](docs/SELF_HOSTING.md)：当前 Compose 部署入口、客户端设置、证书信任与排查。
+- [CrossDesk Server](https://github.com/kunkundi/crossdesk-server)：服务端源码与发布配置。
+- [CrossDesk Web Client](https://github.com/kunkundi/crossdesk-web-client)：浏览器端源码与自托管说明。

-```bash
-sudo docker run -d \
-  --name crossdesk_server \
-  --network host \
-  -e EXTERNAL_IP=xxx.xxx.xxx.xxx \
-  -e INTERNAL_IP=xxx.xxx.xxx.xxx \
-  -e CROSSDESK_SERVER_PORT=xxxx \
-  -e COTURN_PORT=xxxx \
-  -e MIN_PORT=xxxxx \
-  -e MAX_PORT=xxxxx \
-  -v /var/lib/crossdesk:/var/lib/crossdesk \
-  -v /var/log/crossdesk:/var/log/crossdesk \
-  crossdesk/crossdesk-server:v1.1.6
-```
+## 开发与反馈

-上述命令中，用户需注意的参数如下：
+- [源码构建](docs/BUILD.md)：Windows、macOS、Linux、可选编译参数与打包。
+- [iOS 开发说明](apps/ios/README.md)：原生端构建和真机验证。
+- [GUI 架构](docs/gui-architecture.md)：桌面 UI、平台实现与工程结构。
+- [常见问题](docs/FAQ.md)：连接失败、黑屏、文件位置与编译问题。
+- [提交问题](https://github.com/kunkundi/crossdesk/issues)：请附上两端系统、客户端版本、连接方式和可复现步骤。

-#### 配置参数
+## 致谢与许可

- EXTERNAL_IP：服务器公网 IP , 对应 CrossDesk 客户端**自托管服务器配置**中填写的**服务器地址**
- INTERNAL_IP：服务器内网 IP
- CROSSDESK_SERVER_PORT：自托管服务使用的端口，对应 CrossDesk 客户端**自托管服务器配置**中填写的**服务器端口**
- COTURN_PORT: COTURN 服务使用的端口, 对应 CrossDesk 客户端**自托管服务器配置**中填写的**中继服务端口**
- MIN_PORT/MAX_PORT：COTURN 服务使用的端口范围，例如：MIN_PORT=50000, MAX_PORT=60000，范围可根据客户端数量调整。
- `-v /var/lib/crossdesk:/var/lib/crossdesk`：持久化数据库和证书文件到宿主机
- `-v /var/log/crossdesk:/var/log/crossdesk`：持久化日志文件到宿主机
+感谢 [HelloGitHub](https://hellogithub.com/)、[阮一峰的科技爱好者周刊](https://github.com/ruanyf/weekly) 与 [LinuxDo](https://linux.do) 社区的推荐、交流与支持。

-#### 部署示例
+CrossDesk 使用 [GPL-3.0](LICENSE) 许可。隐私说明见 [隐私政策](PRIVACY.md#中文)。

-```bash
-sudo docker run -d \
-  --name crossdesk_server \
-  --network host \
-  -e EXTERNAL_IP=114.114.114.114 \
-  -e INTERNAL_IP=10.0.0.1 \
-  -e CROSSDESK_SERVER_PORT=9099 \
-  -e COTURN_PORT=3478 \
-  -e MIN_PORT=50000 \
-  -e MAX_PORT=60000 \
-  -v /var/lib/crossdesk:/var/lib/crossdesk \
-  -v /var/log/crossdesk:/var/log/crossdesk \
-  crossdesk/crossdesk-server:v1.1.6
-```
-
-#### 注意事项
-
- **服务器需开放端口：COTURN_PORT/udp，COTURN_PORT/tcp，MIN_PORT-MAX_PORT/udp，CROSSDESK_SERVER_PORT/tcp。**
- 如果不挂载 volume，容器删除后数据会丢失
- 证书文件会在首次启动时自动生成并持久化到宿主机的 `/var/lib/crossdesk/certs` 路径下。由于默认使用的是自签证书，无法保障安全性，建议在云服务商申请正式证书放到该目录下并重启服务。
- 数据库文件会自动创建并持久化到宿主机的 `/var/lib/crossdesk/db/crossdesk-server.db` 路径下
- 日志文件会自动创建并持久化到宿主机的 `/var/log/crossdesk/` 路径下
-
-#### 目录权限
-
-如果 Docker 自动创建的目录权限不足（属于 root），容器内用户无法写入，会导致：
-
- 证书生成失败，容器启动脚本会报错退出
- 数据库目录创建失败，程序会抛出异常并崩溃
- 日志目录创建失败，日志文件无法写入（但程序可能继续运行）
-
-在启动容器前手动设置权限：
-
-```bash
-sudo mkdir -p /var/lib/crossdesk /var/log/crossdesk
-sudo chown -R $(id -u):$(id -g) /var/lib/crossdesk /var/log/crossdesk
-```
-
-### 客户端
-
-1. 点击右上角设置进入设置页面。<br><br>
-<img width="600" height="210" alt="image" src="https://github.com/user-attachments/assets/6431131d-b32a-4726-8783-6788f47baa3b" /><br>
-
-2. 点击`自托管服务器配置`按钮。<br><br>
-<img width="600" height="160" alt="image" src="https://github.com/user-attachments/assets/24c761a3-1985-4d7e-84be-787383c2afb8" /><br>
-
-3. 输入`服务器地址`(**EXTERNAL_IP**)、`信令服务端口`(**CROSSDESK_SERVER_PORT**)、`中继服务端口`(**COTURN_PORT**)，点击确认按钮。
-
-4. 勾选`自托管服务器配置`选项，点击确认按钮保存设置。如果服务端使用的是正式证书，则到此步骤为止，客户端即可显示已连接服务器。
-
-5. 如果使用默认证书（正式证书忽略此步骤），则需要将服务端`/var/lib/crossdesk/certs/`目录下的`api.crossdesk.cn_root.crt`自签根证书下载到运行客户端的机器，并执行下述命令安装证书：
-
-**Windows：** 使用管理员权限打开 PowerShell 执行：
-
-```powershell
-certutil -addstore "Root" "C:\path\to\api.crossdesk.cn_root.crt"
-```
-
-**Linux：**
-
-```bash
-sudo cp /path/to/api.crossdesk.cn_root.crt /usr/local/share/ca-certificates/api.crossdesk.cn_root.crt
-sudo update-ca-certificates
-```
-
-**macOS：**
-
-```bash
-sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain path/to/api.crossdesk.cn_root.crt
-```
-
-### 自托管 Web 客户端
-
-详情见项目 [CrossDesk Web Client](https://github.com/kunkundi/crossdesk-web-client)。
-
---
-
-## 常见问题
-
-见 [常见问题](https://github.com/kunkundi/crossdesk/blob/self-hosted-server/docs/FAQ.md)。
-
---
-
-## 致谢
-
- 感谢 [HelloGitHub](https://hellogithub.com/) 的推荐与关注。
- 感谢 [阮一峰的科技爱好者周刊](https://github.com/ruanyf/weekly) 的收录与推荐。
- 感谢 [LinuxDo](https://linux.do) 社区的关注、交流与支持，为 CrossDesk 项目的完善提供了帮助。
-
---
-
-## Code signing policy
+### Code signing policy

 CrossDesk 使用 SignPath.io 为本仓库构建的官方 Windows 发布包提供代码签名。

@@ -431,4 +213,3 @@ CrossDesk 使用 SignPath.io 为本仓库构建的官方 Windows 发布包提供

 - **Committers and reviewers（代码提交与审核）：** [kunkundi](https://github.com/kunkundi)
 - **Approvers（签名审批）：** [kunkundi](https://github.com/kunkundi)
- **隐私政策：** [查看 CrossDesk 隐私政策](PRIVACY.md#中文)
@@ -1,451 +1,215 @@
-# CrossDesk
+<div align="center">
+  <img src="apps/desktop/resources/linux/crossdesk_128x128.png" width="80" alt="CrossDesk logo" />
+  <h1>CrossDesk</h1>
+  <p>A lightweight, cross-platform remote desktop for computers, browsers, and iPhone / iPad.</p>
+  <p><a href="https://www.crossdesk.cn/">Website</a> · <a href="https://github.com/kunkundi/crossdesk/releases">Download</a> · <a href="https://web.crossdesk.cn/">Open Web Client</a> · <a href="README.md">中文</a></p>
+</div>

-<a href="https://hellogithub.com/repository/kunkundi/crossdesk" target="_blank"><img src="https://api.hellogithub.com/v1/widgets/recommend.svg?rid=55d41367570345f1838e02fd12be7961&claim_uid=cb0OpZRrBuGVAfL&theme=small" alt="Featured｜HelloGitHub" /></a>
+<div align="center">

-[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-brightgreen.svg)](https://www.crossdesk.cn/)
-[![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
-[![GitHub last commit](https://img.shields.io/github/last-commit/kunkundi/crossdesk)](https://github.com/kunkundi/crossdesk/commits/web-client)
-[![Build Status](https://github.com/kunkundi/crossdesk/actions/workflows/build.yml/badge.svg)](https://github.com/kunkundi/crossdesk/actions)  
-[![Docker Pulls](https://img.shields.io/docker/pulls/crossdesk/crossdesk-server)](https://hub.docker.com/r/crossdesk/crossdesk-server/tags)
-[![GitHub issues](https://img.shields.io/github/issues/kunkundi/crossdesk.svg)](https://github.com/kunkundi/crossdesk/issues)
-[![GitHub stars](https://img.shields.io/github/stars/kunkundi/crossdesk.svg?style=social)](https://github.com/kunkundi/crossdesk/stargazers)
-[![GitHub forks](https://img.shields.io/github/forks/kunkundi/crossdesk.svg?style=social)](https://github.com/kunkundi/crossdesk/forks)
+[![Platforms](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux%20%7C%20iOS-blue)](#download)
+[![Release](https://img.shields.io/github/v/release/kunkundi/crossdesk)](https://github.com/kunkundi/crossdesk/releases)
+[![Build](https://github.com/kunkundi/crossdesk/actions/workflows/build.yml/badge.svg)](https://github.com/kunkundi/crossdesk/actions/workflows/build.yml)
+[![License: GPL v3](https://img.shields.io/badge/license-GPL--3.0-blue)](LICENSE)
+[![Stars](https://img.shields.io/github/stars/kunkundi/crossdesk?style=social)](https://github.com/kunkundi/crossdesk/stargazers)

-[ [中文](README.md) / English ]
+</div>

---
+CrossDesk connects Windows, macOS, and Linux desktops, with browser and native iOS clients for controlling computers. Built on [MiniRTC](https://github.com/kunkundi/minirtc), it supports real-time video and audio, keyboard and mouse control, file transfer, and self-hosting. The project is under active development.
+
+> This guide follows the current repository source. Desktop screenshots render the current Slint UI with sample IDs, passwords, online statuses, and recent devices; thumbnails show public pages. Check each release's notes for the features and requirements of its binaries. Native iOS build and signing instructions are below.
+
+[Preview](#preview) · [Download](#download) · [Quick start](#quick-start) · [Session controls](#session) · [Settings](#settings) · [iOS](#ios) · [Self-hosting](#self-hosting) · [Build](docs/BUILD_EN.md) · [FAQ](docs/FAQ.md#english)
+
+<a id="preview"></a>

 ## Preview

-### PC Client
+### Desktop client

-![sup_example](https://github.com/user-attachments/assets/3f17d8f3-7c4a-4b63-bae4-903363628687)
-
-### Web Client
+The main window brings together your device ID, connection password, remote connection entry, and recent devices.

 <p align="center">
-  <img width="850" height="550" alt="6bddcbed47ffd4b9988a4037c7f4f524" src="https://github.com/user-attachments/assets/e44f73f9-24ac-46a3-a189-b7f8b6669881" />
+  <img src="docs/images/desktop-main-en.png" width="800" alt="Current desktop UI example showing a connected server and three online devices with page thumbnails" />
 </p>

---
+### Web client

-## Introduction
+Enter a remote device ID and password in your browser without installing the desktop app on the controlling device.

-CrossDesk is a lightweight cross-platform remote desktop software.
+<p align="center">
+  <img src="docs/images/web-client.png" width="800" alt="Current CrossDesk Web Client connection page in Chinese" />
+</p>

-CrossDesk is an experimental application of [MiniRTC](https://github.com/kunkundi/minirtc.git), a lightweight cross-platform real-time audio and video transmission library. MiniRTC provides fundamental capabilities including network traversal ([RFC5245](https://datatracker.ietf.org/doc/html/rfc5245)), video software/hardware encoding and decoding (H264/AV1), audio encoding/decoding ([Opus](https://github.com/xiph/opus)), signaling interaction, network congestion control, and transmission encryption ([SRTP](https://tools.ietf.org/html/rfc3711)).
+See the [screenshot notes](docs/images/README.md) for image sources and refresh instructions.

---
+## Features

-## System Requirements
-
-| Platform | Minimum Version |
+| Capability | Current support |
 | --- | --- |
-| **Windows** | Windows 10 or later (64-bit) |
-| **macOS** | macOS Intel 15.0 or later *(versions between 14.0 and 15.0 can be built manually for compatibility)*<br>macOS Apple Silicon 14.0 or later |
-| **Linux** | Ubuntu 20.04 or later |
+| Cross-platform control | Windows / macOS / Linux desktop control; browser and native iOS controllers |
+| Live video and audio | H.264 / AV1, 30 / 60 fps settings, hardware codec options, and remote audio; availability depends on hardware and build configuration |
+| Devices and displays | Recent connections, device aliases, session tabs, and remote display switching |
+| Input and sharing | Keyboard/mouse input, remote cursor synchronization, shortcuts, text clipboard synchronization, and file transfer |
+| Networking and deployment | Direct P2P connections, TURN relay, an SRTP encryption option, and self-hosted signaling/relay services |
+| Windows protected desktops | CrossDesk Service forwards input on lock screens, sign-in screens, and secure desktops |

---
+Controls and capabilities vary by client. Desktop controls are described below; see the [iOS guide](apps/ios/README.md) for native mobile features.

-## Usage
+<a id="download"></a>

-Enter the remote desktop ID in the menu bar’s “Remote ID” field and click “→” to initiate a remote connection.
+## Download and install

-![usage1](https://github.com/user-attachments/assets/3a4bb59f-c84c-44d2-9a20-11790aac510e)
+Choose a package matching your OS and CPU architecture from [GitHub Releases](https://github.com/kunkundi/crossdesk/releases) or the [website](https://www.crossdesk.cn/).

-If the remote desktop requires a connection password, you must enter the correct password on your side to successfully establish the connection.
+| Platform | Current source / CI baseline | Installation |
+| --- | --- | --- |
+| Windows | Windows 10+, x64 | `.exe` installer; portable builds are also supported |
+| macOS | macOS 14.0+, Intel / Apple Silicon | x64 or arm64 `.pkg` |
+| Linux | Ubuntu 20.04+, amd64 / arm64, glibc 2.31 baseline | `.deb` package |
+| iOS / iPadOS | iOS 16.0+, arm64 physical device | Native controller; build and sign with Xcode, or sign the unsigned CI app |
+| Web | A WebRTC-capable browser | Open [web.crossdesk.cn](https://web.crossdesk.cn/) |

-![password](https://github.com/user-attachments/assets/1beadcce-640d-4f5c-8e77-51917b5294d5)
+On Linux, replace the example filename with the downloaded package name:

-Before connecting, you can customize configuration options in the settings, such as language and video encoding format.
+```bash
+sudo apt install "./crossdesk-linux-amd64-<version>.deb"
+```

-![settings](https://github.com/user-attachments/assets/8bc5468d-7bbb-4e30-95bd-da1f352ac08c)
+**First launch on macOS:** follow the app prompts to grant **Screen Recording** (called **Screen & System Audio Recording** on newer systems) and **Accessibility** under **System Settings → Privacy & Security**. Reopen the app if prompted. These permissions allow desktop capture and remote keyboard/mouse input respectively.

-### Using the Web Client
+<a id="quick-start"></a>

-Visit [CrossDesk Web Client](https://web.crossdesk.cn/).
-Enter the **Remote Device ID** and **Password**, then click Connect to access the remote device. As shown, **iOS Safari remotely controlling Windows 11**:
+## Quick start

-<img width="645" height="300" alt="_cgi-bin_mmwebwx-bin_webwxgetmsgimg__ MsgID=932911462648581698 skey=@crypt_1f5153b1_b550ca7462b5009ce03c991cca2a92a7 mmweb_appid=wx_webfilehelper" src="https://github.com/user-attachments/assets/a5109e6f-752c-4654-9f4e-7e161bddf43e" />
+### Connect from another computer

-### Windows Service (CrossDesk Service)
+1. **Prepare the host.** Install and run CrossDesk on the computer to control. Wait for the bottom status bar to show that the server is connected. Share the **Local ID** and **Password** shown under **Local Desktop** with the controller.
+2. **Enter the remote ID.** On the controlling computer, enter the host's ID in **Remote Desktop → Remote ID**, then click **→**.
+3. **Verify the password.** Enter the host's current connection password when prompted and confirm. Select **Remember password** if you want to save it.
+4. **Reconnect later.** Previously connected devices appear under **Recent Connections**. Reconnect from a card, edit its alias, or remove its record.

-CrossDesk provides a local helper service on Windows named **CrossDesk Service**. Its service name is `CrossDeskService`. The service improves remote control in protected Windows states such as the lock screen, sign-in UI, credential UI, and secure desktop. It provides:
+The eye button shows or hides the local password; the pencil button changes it. Use **6 ASCII letters or digits** and stay connected to the server while changing it. Wait for the change to succeed and the client to reconnect, then copy the current password. Controllers that saved the old password must enter it again.

- Remote status reporting for lock screen, sign-in, credential, and secure desktop states.
- Remote `Ctrl+Alt+Del` (SAS) delivery.
- Keyboard and mouse input forwarding while the remote Windows device is on the lock screen, sign-in UI, or secure desktop.
+### Connect from a browser

-The Windows installer bundles `crossdesk_service.exe` and `crossdesk_session_helper.exe`, then registers the service as an on-demand Windows service during installation. When the CrossDesk client starts, it tries to start the installed service automatically. When no CrossDesk client process is running on the machine, the service exits automatically. Uninstalling the client also stops and removes the service.
+1. Keep CrossDesk running and connected to the server on the host computer, with **Enable SRTP** enabled in its Settings.
+2. Open the [Web Client](https://web.crossdesk.cn/), enter the **Remote Device ID** and **Password**, and click **Connect**.
+3. Use the page's display, mouse-mode, and keyboard controls during the session. Phone and tablet browsers can also connect.

-For manual Windows builds or deployments, make sure `CrossDesk.exe`, `crossdesk_service.exe`, and `crossdesk_session_helper.exe` are placed in the same directory. Open PowerShell with administrator privileges to install or uninstall the service:
+For self-hosting, connect both sides to the same service. Browser deployment is documented in [CrossDesk Web Client](https://github.com/kunkundi/crossdesk-web-client).
+
+<a id="session"></a>
+
+## Session controls
+
+Switch devices using session tabs. Expand the control bar if it is collapsed, and hover over icons to see their tooltips.
+
+| Control | Action |
+| --- | --- |
+| Display | Switch the remote monitor |
+| Keyboard | Send shortcuts; Windows `Ctrl+Alt+Del` requires the remote service |
+| Mouse | Enable / release remote mouse control |
+| Speaker | Play / mute remote audio |
+| Folder | Select a file to send and view transfer progress |
+| Network statistics | Inspect traffic, packet loss, frame rate, resolution, and direct / relay mode |
+| Fullscreen | Enter / exit fullscreen |
+| Disconnect | End the current remote session |
+
+Desktop clients synchronize text clipboard contents. Configure the receiving directory under **Settings → File Save Path**. Closing the main window hides it and keeps the app running; use the system tray or menu-bar exit command to quit completely.
+
+<a id="settings"></a>
+
+## Video and connection settings
+
+Open **☰ → Settings** in the top-right corner and click **OK** to save. Configure the session before connecting; some settings are disabled during an active session. Scroll down for self-hosting, startup behavior, and the file save path.
+
+<p align="center">
+  <img src="docs/images/desktop-settings-en.png" width="720" alt="Current settings for quality, frame rate, video preference, codecs, relay, and SRTP" />
+</p>
+
+| Setting | Purpose |
+| --- | --- |
+| Video Quality / Video Capture Frame Rate | Low, medium, or high quality and 30 / 60 fps; actual performance depends on the connection and device |
+| Video Preference | Choose frame-rate priority, quality priority, or balanced adaptation |
+| Video Encode Format | H.264 / AV1; hardware codec availability depends on the platform, device, and build options |
+| Enable TURN Service | Allow relay-assisted connections; check this setting if P2P fails |
+| SRTP | Media encryption option; configurations on both ends must be compatible |
+| Self-Hosted Config | Set the host, signaling port, and TURN port, then enable the checkbox |
+| Auto Start / Enable Daemon | Configure startup and process supervision; restart as indicated by the UI |
+| File Save Path | Choose where received files are saved |
+
+<a id="ios"></a>
+
+## Native iOS / iPadOS client
+
+[`apps/ios`](apps/ios/README.md) contains a native controller using the same MiniRTC protocol as the desktop client. It controls remote computers; it does not expose an iPhone or iPad as a remotely controlled desktop.
+
+1. Follow the [iOS guide](apps/ios/README.md) to build and sign the app with Xcode, then install it on an iOS 16+ physical device.
+2. Enter a remote ID on the home screen, connect, and enter its password. Successful connections become available in the recent devices list.
+3. Choose a mouse mode in Settings: **Relative Position** works like a trackpad; **Absolute Position** maps touches directly to the remote screen.
+4. Tap the floating icon to expand the menu, then switch displays, open the keyboard, toggle audio, or send files. Received files are stored in `Documents/Received` and can be exported using the share button beside the transfer status.
+
+The app currently receives remote text into the iOS clipboard. Its UI does not yet expose a button to send the local clipboard.
+
+Gestures include one-finger click, two-finger right-click, long-press drag, and pinch-to-zoom. When zoomed in, two-finger panning moves the viewport. The native and browser clients are maintained separately, so their controls and gestures may differ. The current native UI uses Chinese labels.
+
+<a id="windows-service"></a>
+
+## Windows lock screens and sign-in
+
+**CrossDesk Service** (`CrossDeskService`) reports protected desktop states and forwards `Ctrl+Alt+Del`, keyboard, and mouse input on lock screens, sign-in screens, credential prompts, and secure desktops.
+
+The installer registers an on-demand service. CrossDesk tries to start it on launch, and the service exits when no local CrossDesk client is running. Portable builds offer service installation in the prompt or **Settings → Lock Screen Service**, with administrator privileges. The service depends on a running client.
+
+<details>
+<summary>Manual deployment and service commands</summary>
+
+Keep the complete installation directory. For manual deployment, place `CrossDesk.exe`, `crossdesk_service.exe`, `crossdesk_session_helper.exe`, and all `.dll` files from the same build together. Open an administrator PowerShell in that directory and run the commands you need:

 ```powershell
-# install
 .\CrossDesk.exe --service-install
-# start
 .\CrossDesk.exe --service-start
-# check status
 .\CrossDesk.exe --service-status
 .\CrossDesk.exe --service-ping
-# stop
+# Stop or uninstall the service
 .\CrossDesk.exe --service-stop
-# uninstall
 .\CrossDesk.exe --service-uninstall
 ```

-If the remote Windows service is not installed, not running, or temporarily unavailable, the basic remote desktop connection still works, but remote control on the lock screen, sign-in UI, and secure desktop is limited. The client will show “Remote Windows service unavailable”.
+</details>

---
+If **Remote Windows service unavailable** appears, check installation and service status on the host. Ordinary desktop connections remain available, while control of protected screens is limited.

-## How to build
+<a id="self-hosting"></a>

-### Build requirements
+## Self-hosting

- [xmake](https://xmake.io/#/guide/installation)
- [cmake](https://cmake.org/download/) 3.21 or later (installed automatically by xmake when the system version is too old)
+Host your own signaling and TURN services, then enter their connection details under **☰ → Settings → Self-Hosted Config**. Enable the same server configuration on both the controller and host.

-### Linux
+- [Self-hosting guide](docs/SELF_HOSTING_EN.md): current Compose deployment, client settings, certificate trust, and troubleshooting.
+- [CrossDesk Server](https://github.com/kunkundi/crossdesk-server): server source and release configuration.
+- [CrossDesk Web Client](https://github.com/kunkundi/crossdesk-web-client): browser source and deployment instructions.

-Linux builds support Ubuntu 20.04 or later on amd64 and arm64. Release packages
-use Ubuntu 20.04/glibc 2.31 as their compatibility baseline. Install the base
-build dependencies first:
+## Development and feedback

-```bash
-sudo apt-get update
-sudo apt-get install -y \
-  git curl unzip build-essential gcc-10 g++-10 python3-pip \
-  pkg-config binutils dpkg-dev \
-  libx11-dev libxext-dev libxrender-dev libxft-dev libxrandr-dev \
-  libxinerama-dev libxcursor-dev libxi-dev libxfixes-dev libxv-dev \
-  libxtst-dev libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev \
-  libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxcb-shm0-dev \
-  libasound2-dev libsndio-dev libpulse-dev \
-  libgl1-mesa-dev
-```
+- [Build from source](docs/BUILD_EN.md): Windows, macOS, Linux, optional flags, and packaging.
+- [iOS development](apps/ios/README.md): native build and physical-device checks.
+- [GUI architecture](docs/gui-architecture.md): desktop UI and platform organization.
+- [FAQ](docs/FAQ.md#english): connection failures, blank video, received files, and build issues.
+- [Report an issue](https://github.com/kunkundi/crossdesk/issues): include both operating systems, client versions, connection mode, and reproduction steps.

-When Ubuntu 20.04's bundled CMake 3.16 is too old, xmake automatically
-downloads and uses CMake 3.21 or later; replacing the system CMake manually is
-not required.
+## Acknowledgements and license

-Ubuntu 20.04's default GCC 9 lacks parts of the C++20 standard library needed
-by Slint's C++ API, so the commands above install GCC 10 and the configuration
-below selects it explicitly.
+Thanks to [HelloGitHub](https://hellogithub.com/), [Ruanyf Weekly](https://github.com/ruanyf/weekly), and the [LinuxDo](https://linux.do) community for featuring CrossDesk and contributing feedback.

-Install the optional dependencies when Wayland capture or DRM capture is enabled:
+CrossDesk is licensed under [GPL-3.0](LICENSE). See the [Privacy Policy](PRIVACY.md#english).

-```bash
-sudo apt-get install -y libdbus-1-dev libdrm-dev
+### Code signing policy

-# Ubuntu 22.04 and later can alternatively use the distribution packages.
-# sudo apt-get install -y libpipewire-0.3-dev libspa-0.2-dev
-```
-
-Clone the submodules and build a release binary:
-
-```bash
-git clone --recurse-submodules https://github.com/kunkundi/crossdesk.git
-cd crossdesk
-
-# Run this when the repository has already been cloned
-git submodule update --init --recursive
-
-# Ubuntu 20.04 has no PipeWire 0.3 development package. Install the
-# header-only SDK used during compilation. Skip this when the distribution's
-# PipeWire 0.3 development packages are already installed.
-sudo ./docker/linux-build/install-pipewire-sdk.sh
-
-xmake f -c -m release --USE_CUDA=false --toolchain=gcc-10 -y
-xmake b -vy crossdesk
-```
-
-Use `--toolchain=gcc-10` so that both CrossDesk and third-party packages such
-as libyuv, which xmake builds during configuration, use GCC 10. Specifying only
-`--cc`/`--cxx` may still let dependency builds fall back to the system
-`/bin/cc` and `/bin/c++`. Keep `-c` when switching compilers to clear the old
-configuration.
-
-The amd64 binary is written to `build/linux/x86_64/release/crossdesk`; the arm64 binary is written to `build/linux/arm64/release/crossdesk`.
-
-Example configuration with Wayland and DRM capture enabled:
-
-```bash
-xmake f -c -m release --USE_WAYLAND=true --USE_DRM=true --USE_CUDA=false \
-  --toolchain=gcc-10 -y
-xmake b -vy crossdesk
-```
-
-Build a Debian package after compiling a release binary on the matching architecture:
-
-```bash
-# amd64
-./scripts/linux/pkg_amd64.sh 1.0.0
-
-# arm64
-./scripts/linux/pkg_arm64.sh 1.0.0
-```
-
-The package scripts install the shared Slint runtime in the private `/usr/lib/crossdesk` directory, so users do not need to install `libslint_cpp.so` separately.
-PipeWire is not a mandatory runtime dependency. CrossDesk detects the host's
-PipeWire 0.3 runtime dynamically and can still use X11 capture (and DRM when
-enabled at build time) when it is unavailable.
-
-### Common build options
-
-```text
--USE_CUDA=true/false: Enable CUDA hardware codec acceleration, disabled by default
--USE_WAYLAND=true/false: Enable Wayland/PipeWire capture on Linux, disabled by default
--USE_DRM=true/false: Enable DRM capture on Linux, disabled by default
--CROSSDESK_PORTABLE=true/false: Build the portable variant, disabled by default
--CROSSDESK_VERSION=xxx: Set the CrossDesk version
-
-# Example
-xmake f --CROSSDESK_VERSION=1.0.0 --USE_CUDA=true
-```
-
-Run:
-
-```bash
-xmake r crossdesk
-```
-
-### Development Without CUDA Environment
-
-For **Linux developers who do not have a CUDA environment installed and want to enable hardware codec feature**, a preconfigured [Ubuntu 20.04 compatibility build image](https://hub.docker.com/r/crossdesk/ubuntu20.04) is provided.
-This image contains the required build dependencies and produces a single Linux package compatible with the glibc 2.31 baseline.
-
-After entering the container, download the project and run:
-
-```bash
-export CUDA_PATH=/usr/local/cuda
-export XMAKE_GLOBALDIR=/data
-
-xmake f --USE_CUDA=true
-xmake b --root -vy crossdesk
-```
-
-For **Windows developers without a CUDA environment** installed, run the following command to install the CUDA build environment:
-
-```powershell
-xmake require -vy "cuda 12.6.3"
-```
-
-After the installation is complete, execute:
-
-```powershell
-xmake require --info "cuda 12.6.3"
-```
-
-The output will look like this:
-
-<img width="860" height="226" alt="Image" src="https://github.com/user-attachments/assets/999ac365-581a-4b9a-806e-05eb3e4cf44d" />
-
-From the output above, locate the CUDA installation directory — this is the path pointed to by installdir.
-Add this path to your system environment variable CUDA_PATH, or set it in the terminal using:
-
-```powershell
-set CUDA_PATH=path_to_cuda_installdir
-```
-
-Then re-run:
-
-```powershell
-xmake f --USE_CUDA=true
-xmake b -vy crossdesk
-```
-
-#### Notice
-
-If the client status bar shows **Disconnected** during runtime, please first install the client from the [CrossDesk official website](https://www.crossdesk.cn/) to ensure the required certificate files are available in the environment.
-
-<img width="256" height="120" alt="image" src="https://github.com/user-attachments/assets/1812f7d6-516b-4b4f-8a3d-98bee505cc5a" />
-
-### About Xmake
-
-#### Installing Xmake
-
-You can install Xmake using one of the following methods:
-
-Using curl:
-
-```bash
-curl -fsSL https://xmake.io/shget.text | bash
-```
-
-Using wget:
-
-```bash
-wget https://xmake.io/shget.text -O - | bash
-```
-
-Using powershell:
-
-```powershell
-irm https://xmake.io/psget.text | iex
-```
-
-#### Build Options
-
-```text
-# Switch build mode
-xmake f -m debug/release
-
-# Optional build parameters
-r : Rebuild the target
-v : Show detailed build logs
-y : Automatically confirm prompts
-
-# Example
-xmake b -vy crossdesk
-```
-
-#### Run Options
-
-```bash
-# Run in debug mode
-xmake r -d crossdesk
-```
-
-For more information, please refer to the [official Xmake documentation](https://xmake.io/guide/quick-start.html).
-
---
-
-## Self-Hosted Server
-
-### Server
-
-It is recommended to deploy CrossDesk Server using Docker.
-
-```bash
-sudo docker run -d \
-  --name crossdesk_server \
-  --network host \
-  -e EXTERNAL_IP=xxx.xxx.xxx.xxx \
-  -e INTERNAL_IP=xxx.xxx.xxx.xxx \
-  -e CROSSDESK_SERVER_PORT=xxxx \
-  -e COTURN_PORT=xxxx \
-  -e MIN_PORT=xxxxx \
-  -e MAX_PORT=xxxxx \
-  -v /var/lib/crossdesk:/var/lib/crossdesk \
-  -v /var/log/crossdesk:/var/log/crossdesk \
-  crossdesk/crossdesk-server:v1.1.6
-```
-
-The parameters you need to pay attention to are as follows:
-
-#### Parameters
-
- **EXTERNAL_IP**: The server’s public IP. This corresponds to **Server Address** in the CrossDesk client’s **Self-Hosted Server Configuration**.
- **INTERNAL_IP**: The server’s internal IP.
- **CROSSDESK_SERVER_PORT**: The port used by the self-hosted service. This corresponds to **Server Port** in the CrossDesk client’s **Self-Hosted Server Configuration**.
- **COTURN_PORT**: The port used by the COTURN service. This corresponds to **Relay Service Port** in the CrossDesk client’s **Self-Hosted Server Configuration**.
- **MIN_PORT / MAX_PORT**: The port range used by the COTURN service. Example: `MIN_PORT=50000`, `MAX_PORT=60000`. Adjust the range depending on the number of clients.
- `-v /var/lib/crossdesk:/var/lib/crossdesk`: Persists database and certificate files on the host machine.
- `-v /var/log/crossdesk:/var/log/crossdesk`: Persists log files on the host machine.
-
-#### Example
-
-```bash
-sudo docker run -d \
-  --name crossdesk_server \
-  --network host \
-  -e EXTERNAL_IP=114.114.114.114 \
-  -e INTERNAL_IP=10.0.0.1 \
-  -e CROSSDESK_SERVER_PORT=9099 \
-  -e COTURN_PORT=3478 \
-  -e MIN_PORT=50000 \
-  -e MAX_PORT=60000 \
-  -v /var/lib/crossdesk:/var/lib/crossdesk \
-  -v /var/log/crossdesk:/var/log/crossdesk \
-  crossdesk/crossdesk-server:v1.1.6
-```
-
-#### Notes
-
- **The server must open the following ports: COTURN_PORT/udp, COTURN_PORT/tcp, MIN_PORT–MAX_PORT/udp, and CROSSDESK_SERVER_PORT/tcp.**
- If you don’t mount volumes, all data will be lost when the container is removed.
- Certificate files will be automatically generated on first startup and persisted to the host at `/var/lib/crossdesk/certs`. As the default certificates are self-signed and cannot guarantee security, it is strongly recommended to apply for a trusted certificate from a cloud provider, deploy it to this directory, and restart the service.
- The database file will be automatically created and stored at `/var/lib/crossdesk/db/crossdesk-server.db`.
- Log files will be created and stored at `/var/log/crossdesk/`.
-
-#### Directory permissions
-
-If the directories automatically created by Docker belong to root and have insufficient write permissions, the container user may not be able to write to them. This can cause:
-
- Certificate generation failure, leading to startup script errors and container exit.
- Database directory creation failure, causing the program to throw exceptions and crash.
- Log directory creation failure, preventing logs from being written (though the program may continue running).
-
-Manually set permissions before starting the container:
-
-```bash
-sudo mkdir -p /var/lib/crossdesk /var/log/crossdesk
-sudo chown -R $(id -u):$(id -g) /var/lib/crossdesk /var/log/crossdesk
-```
-
-#### TLS certificate
-
-Place **crossdesk.cn.key** and **crossdesk.cn_bundle.crt** into the **/path/to/your/certs** directory.
-
-### Client
-
-1. Click the settings icon in the top-right corner to enter the settings page.<br><br>
-<img width="600" height="210" alt="image" src="https://github.com/user-attachments/assets/6431131d-b32a-4726-8783-6788f47baa3b" /><br>
-
-2. Click `Self-Hosted Server Configuration` button.<br><br>
-<img width="600" height="160" alt="image" src="https://github.com/user-attachments/assets/24c761a3-1985-4d7e-84be-787383c2afb8" /><br>
-
-3. Enter the `Server Address` (**EXTERNAL_IP**), `Signaling Service Port` (**CROSSDESK_SERVER_PORT**), and `Relay Service Port` (**COTURN_PORT**) and click OK button.
-
-4. Check the `Self-hosted server configuration` option and click the OK button to save the settings. If the server is using a valid (official) certificate, the process ends here and the client will show that it is connected to the server.
-
-5. If the default certificate is used (skip this step if an official certificate is used), download the self-signed root certificate `api.crossdesk.cn_root.crt` from the server directory /var/lib/crossdesk/certs/ to the machine running the client, and install the certificate by executing the following command:
-
-**Windows:** Open PowerShell with administrator privileges and execute:
-
-```powershell
-certutil -addstore "Root" "C:\path\to\api.crossdesk.cn_root.crt"
-```
-
-**Linux:**
-
-```bash
-sudo cp /path/to/api.crossdesk.cn_root.crt /usr/local/share/ca-certificates/api.crossdesk.cn_root.crt
-sudo update-ca-certificates
-```
-
-**macOS:**
-
-```bash
-sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain path/to/api.crossdesk.cn_root.crt
-```
-
-### Self-Hosted Web Client
-
-See [CrossDesk Web Client](https://github.com/kunkundi/crossdesk-web-client).
-
---
-
-## FAQ
-
-See [FAQ](https://github.com/kunkundi/crossdesk/blob/self-hosted-server/docs/FAQ.md).
-
---
-
-## Acknowledgements
-
- Thanks to [HelloGitHub](https://hellogithub.com/) for the recommendation and exposure.
- Thanks to [Ruanyf Weekly](https://github.com/ruanyf/weekly) for featuring CrossDesk.
- Thanks to the [LinuxDo](https://linux.do) community for the attention, discussions, and support that helped improve CrossDesk.
-
---
-
-## Code signing policy
-
-CrossDesk uses SignPath.io to code-sign official Windows releases built from this repository.
+CrossDesk uses SignPath.io to sign official Windows releases built from this repository.

 **Free code signing provided by [SignPath.io](https://signpath.io/), certificate by [SignPath Foundation](https://signpath.org/).**

 - **Committers and reviewers:** [kunkundi](https://github.com/kunkundi)
 - **Approvers:** [kunkundi](https://github.com/kunkundi)
- **Privacy policy:** [Read the CrossDesk Privacy Policy](PRIVACY.md#english)
@@ -1,5 +1,5 @@
 // Application icon resource; load by the resource name IDI_ICON1.
-IDI_ICON1 ICON "..\\..\\icons\\windows\\crossdesk.ico"
+IDI_ICON1 ICON "crossdesk.ico"

 #define CREATEPROCESS_MANIFEST_RESOURCE_ID 1
 #define RT_MANIFEST 24
@@ -1,6 +1,6 @@
 // Portable build resource. The app itself runs as the current user; service
 // installation raises a separate UAC prompt only when the user chooses it.
-IDI_ICON1 ICON "..\\..\\icons\\windows\\crossdesk.ico"
+IDI_ICON1 ICON "crossdesk.ico"

 #define CREATEPROCESS_MANIFEST_RESOURCE_ID 1
 #define RT_MANIFEST 24
@@ -0,0 +1,13 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-11
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+IDI_CROSSDESK_LOGO ICON "crossdesk.ico"
+
+#define CROSSDESK_FILE_DESCRIPTION "CrossDesk Privacy Window"
+#define CROSSDESK_ORIGINAL_FILENAME "crossdesk_privacy_window.dll"
+#define CROSSDESK_FILE_TYPE VFT_DLL
+
+#include "version_info.rcinc"
@@ -1,5 +1,5 @@
 // Session helper icon and manifest resources.
-IDI_ICON1 ICON "..\\..\\icons\\windows\\crossdesk.ico"
+IDI_ICON1 ICON "crossdesk.ico"

 #define CREATEPROCESS_MANIFEST_RESOURCE_ID 1
 #define RT_MANIFEST 24
@@ -1,6 +1,9 @@
 #!/usr/bin/env bash
 set -euo pipefail

+# Keep readelf and ldd output stable for the runtime dependency checks below.
+export LC_ALL=C
+
 if [[ $# -lt 3 || $# -gt 4 ]]; then
    echo "Usage: $0 <debian-arch> <xmake-arch> <version> [extra-recommendation]" >&2
    exit 2
@@ -20,7 +23,7 @@ PORTAL_RUNTIME_RECOMMENDS="xdg-desktop-portal, xdg-desktop-portal-gtk | xdg-desk
 TRAY_RUNTIME_RECOMMENDS="libayatana-appindicator3-1 | libappindicator3-1"

 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"

 normalize_app_version() {
    local input="$1"
@@ -84,7 +87,7 @@ if [[ ! -x "$BUILD_BINARY" ]]; then
    exit 1
 fi

-for command_name in readelf ldd dpkg-deb; do
+for command_name in readelf ldd dpkg-deb strip; do
    if ! command -v "$command_name" >/dev/null 2>&1; then
        echo "Required packaging command is missing: $command_name" >&2
        exit 1
@@ -125,6 +128,9 @@ if [[ -n "$SLINT_NEEDED" ]]; then
        exit 1
    fi
    install -m 0755 "$SLINT_LIBRARY" "$PRIVATE_DIR/$SLINT_NEEDED"
+    # Keep dynamic exports/relocations while removing unneeded symbols from the
+    # staged copy. Never strip Xmake's cached runtime in place.
+    strip --strip-unneeded "$PRIVATE_DIR/$SLINT_NEEDED"
 fi

 cat > "$BIN_DIR/$PKG_NAME" <<'EOF'
@@ -142,7 +148,7 @@ ln -s "$PKG_NAME" "$BIN_DIR/$APP_NAME"

 for size in 16 24 32 48 64 96 128 256; do
    install -d "$ICON_BASE_DIR/${size}x${size}/apps"
-    install -m 0644 "$PROJECT_ROOT/icons/linux/crossdesk_${size}x${size}.png" \
+    install -m 0644 "$PROJECT_ROOT/apps/desktop/resources/linux/crossdesk_${size}x${size}.png" \
        "$ICON_BASE_DIR/${size}x${size}/apps/${PKG_NAME}.png"
 done

@@ -158,7 +164,7 @@ Architecture: $DEBIAN_ARCH
 Maintainer: $MAINTAINER
 Description: $DESCRIPTION
 Depends: libc6 (>= 2.31), libstdc++6 (>= 10), libx11-6, libxext6,
- libxrender1, libxft2, libxrandr2, libxfixes3, libxcursor1, libxcb1, libxcb-randr0,
+ libxrender1, libxft2, libxrandr2, libxfixes3, libxcursor1, libxi6, libxcb1, libxcb-randr0,
 libxcb-xtest0, libxcb-xinerama0, libxcb-shape0, libxcb-xkb1,
 libxcb-xfixes0, libxv1, libxtst6, $ALSA_RUNTIME_DEP, libsndio7.0,
 libxcb-shm0, libpulse0, libdrm2, libdbus-1-3, libgl1
@@ -169,11 +175,12 @@ EOF

 cat > "$DESKTOP_DIR/$PKG_NAME.desktop" <<EOF
 [Desktop Entry]
-Version=$DEB_VERSION
+Version=1.0
 Name=$APP_NAME
 Comment=$DESCRIPTION
 Exec=/usr/bin/$PKG_NAME
 Icon=$PKG_NAME
+StartupWMClass=$PKG_NAME
 Terminal=false
 Type=Application
 Categories=Utility;
@@ -11,7 +11,7 @@ EXPECTED_ARCH="$2"
 APP_EXECUTABLE="$APP_BUNDLE/Contents/MacOS/CrossDesk"
 FRAMEWORKS_DIR="$APP_BUNDLE/Contents/Frameworks"

-for command_name in codesign install_name_tool lipo otool; do
+for command_name in codesign install_name_tool lipo otool strip; do
    if ! command -v "$command_name" >/dev/null 2>&1; then
        echo "Required bundling command is missing: $command_name" >&2
        exit 1
@@ -123,7 +123,11 @@ if ! otool -l "$APP_EXECUTABLE" | awk '
    install_name_tool -add_rpath "@executable_path/../Frameworks" "$APP_EXECUTABLE"
 fi

-# install_name_tool invalidates the linker's ad-hoc signature. Sign nested code
+# Strip only the staged runtime, retaining exported symbols for Slint's C ABI.
+# The package cache remains intact for debugging and other consumers.
+strip -S -x "$FRAMEWORKS_DIR/$SLINT_NAME"
+
+# install_name_tool and strip invalidate the linker's ad-hoc signature. Sign nested code
 # first, then seal the complete app bundle so local packages remain launchable.
 codesign --force --sign - "$FRAMEWORKS_DIR/$SLINT_NAME"
 codesign --force --deep --sign - "$APP_BUNDLE"
@@ -1,16 +1,19 @@
 #!/usr/bin/env bash
 set -euo pipefail

+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
 APP_NAME="crossdesk"
 APP_NAME_UPPER="CrossDesk"
-EXECUTABLE_PATH="./build/macosx/arm64/release/crossdesk"
+EXECUTABLE_PATH="${PROJECT_ROOT}/build/macosx/arm64/release/crossdesk"
 PLATFORM="macos"
 ARCH="arm64"
 BINARY_ARCH="arm64"
 IDENTIFIER="cn.crossdesk.app"
-ICON_PATH="icons/macos/crossdesk.icns"
+ICON_PATH="${PROJECT_ROOT}/apps/desktop/resources/macos/crossdesk.icns"
 MACOS_MIN_VERSION="14.0"
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+cd "$PROJECT_ROOT"

 normalize_app_version() {
    local input="$1"
@@ -103,7 +106,7 @@ find "${APP_BUNDLE}" -name '._*' -delete
 echo ".app created successfully."

 mkdir -p build_pkg_scripts
-cp scripts/macosx/tcc_postinstall.sh build_pkg_scripts/postinstall
+cp "${SCRIPT_DIR}/tcc_postinstall.sh" build_pkg_scripts/postinstall
 chmod +x build_pkg_scripts/postinstall

 mkdir -p build_pkg_resources
@@ -1,16 +1,19 @@
 #!/usr/bin/env bash
 set -euo pipefail

+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
 APP_NAME="crossdesk"
 APP_NAME_UPPER="CrossDesk"
-EXECUTABLE_PATH="build/macosx/x86_64/release/crossdesk"
+EXECUTABLE_PATH="${PROJECT_ROOT}/build/macosx/x86_64/release/crossdesk"
 PLATFORM="macos"
 ARCH="x64"
 BINARY_ARCH="x86_64"
 IDENTIFIER="cn.crossdesk.app"
-ICON_PATH="icons/macos/crossdesk.icns"
+ICON_PATH="${PROJECT_ROOT}/apps/desktop/resources/macos/crossdesk.icns"
 MACOS_MIN_VERSION="14.0"
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+cd "$PROJECT_ROOT"

 normalize_app_version() {
    local input="$1"
@@ -103,7 +106,7 @@ find "${APP_BUNDLE}" -name '._*' -delete
 echo ".app created successfully."

 mkdir -p build_pkg_scripts
-cp scripts/macosx/tcc_postinstall.sh build_pkg_scripts/postinstall
+cp "${SCRIPT_DIR}/tcc_postinstall.sh" build_pkg_scripts/postinstall
 chmod +x build_pkg_scripts/postinstall

 mkdir -p build_pkg_resources
@@ -12,7 +12,7 @@
 !define PRODUCT_SERVICE_NAME "CrossDeskService"

 ; Installer icon path
-!define MUI_ICON "${__FILEDIR__}\..\..\icons\windows\crossdesk.ico"
+!define MUI_ICON "${__FILEDIR__}\..\..\resources\windows\crossdesk.ico"

 ; Compression settings
 SetCompressor /FINAL lzma
@@ -84,12 +84,14 @@ installApp:
    SetOverwrite ifnewer

    ; Main application executable path
-    File /oname=CrossDesk.exe "..\..\build\windows\x64\release\crossdesk.exe"
+    File /oname=CrossDesk.exe "..\..\..\..\build\windows\x64\release\crossdesk.exe"
    ; Bundle service-side binaries required by the Windows service flow
-    File "..\..\build\windows\x64\release\crossdesk_service.exe"
-    File "..\..\build\windows\x64\release\crossdesk_session_helper.exe"
+    File "..\..\..\..\build\windows\x64\release\crossdesk_service.exe"
+    File "..\..\..\..\build\windows\x64\release\crossdesk_session_helper.exe"
+    File "..\..\..\..\build\windows\x64\release\crossdesk_privacy_cursor_helper.exe"
+    File "..\..\..\..\build\windows\x64\release\crossdesk_privacy_window.dll"
    ; Bundle runtime DLLs from the release output directory
-    File "..\..\build\windows\x64\release\*.dll"
+    File /x crossdesk_privacy_window.dll "..\..\..\..\build\windows\x64\release\*.dll"

    Call RegisterInstalledService

@@ -145,6 +147,8 @@ uninstallApp:
    Delete "$INSTDIR\CrossDesk.exe"
    Delete "$INSTDIR\crossdesk_service.exe"
    Delete "$INSTDIR\crossdesk_session_helper.exe"
+    Delete "$INSTDIR\crossdesk_privacy_cursor_helper.exe"
+    Delete "$INSTDIR\crossdesk_privacy_window.dll"
    Delete "$INSTDIR\uninstall.exe"

    ; Recursively delete installation directory
@@ -0,0 +1,76 @@
+#include "daemon.h"
+
+#include <chrono>
+#include <iostream>
+#include <thread>
+#include <utility>
+
+#include "platform/daemon_backend.h"
+
+namespace {
+
+constexpr int kRestartDelayMs = 1000;
+
+}  // namespace
+
+Daemon::Daemon(const std::string& name) : name_(name), running_(false) {}
+
+void Daemon::stop() {
+  running_.store(false);
+  crossdesk::platform::RequestDaemonStop();
+}
+
+bool Daemon::isRunning() const {
+  return running_.load() && !crossdesk::platform::DaemonStopRequested();
+}
+
+bool Daemon::start(MainLoopFunc loop) {
+  crossdesk::platform::ResetDaemonStop();
+  if (!crossdesk::platform::PrepareDaemon()) return false;
+  running_.store(true);
+  return runWithRestart(std::move(loop));
+}
+
+bool Daemon::runWithRestart(MainLoopFunc loop) {
+  int restart_count = 0;
+  const std::string executable_path =
+      crossdesk::platform::GetDaemonExecutablePath();
+  if (executable_path.empty()) {
+    std::cerr
+        << "Failed to get executable path, falling back to direct execution"
+        << std::endl;
+    while (isRunning()) {
+      try {
+        loop();
+        break;
+      } catch (...) {
+        ++restart_count;
+        std::cerr << "Exception caught, restarting... (attempt "
+                  << restart_count << ")" << std::endl;
+        std::this_thread::sleep_for(
+            std::chrono::milliseconds(kRestartDelayMs));
+      }
+    }
+    return true;
+  }
+
+  while (isRunning()) {
+    const crossdesk::platform::DaemonChildResult result =
+        crossdesk::platform::RunDaemonChild(
+            executable_path, [this] { return isRunning(); });
+    if (!isRunning() || result.normal_exit) break;
+
+    ++restart_count;
+    if (!result.started) {
+      std::cerr << "Failed to create child process";
+    } else if (result.terminated_by_signal) {
+      std::cerr << "Child process crashed with signal " << result.exit_code;
+    } else {
+      std::cerr << "Child process exited with code " << result.exit_code;
+    }
+    std::cerr << ", restarting... (attempt " << restart_count << ")"
+              << std::endl;
+    std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
+  }
+  return true;
+}
@@ -8,7 +8,6 @@
 #define _DAEMON_H_

 #include <atomic>
-#include <csignal>
 #include <functional>
 #include <string>

@@ -28,9 +27,6 @@ class Daemon {
  std::string name_;
  bool runWithRestart(MainLoopFunc loop);

-#ifndef _WIN32
-  static volatile std::sig_atomic_t stop_requested_;
-#endif
  std::atomic<bool> running_;
 };

@@ -15,14 +15,20 @@
 #ifdef _WIN32
 #include <cstdio>

+#include "platform/windows/gui/slint_backend.h"
 #include "service_host.h"
 #endif

 #include "config_center.h"
 #include "daemon.h"
 #include "path_manager.h"
+#include "rd_log.h"
 #include "render.h"

+#ifdef __linux__
+#include "platform/linux/privacy/privacy_guard.h"
+#endif
+
 #ifdef _WIN32
 namespace {

@@ -174,6 +180,26 @@ int HandleServiceCliCommand(const std::string& command) {
 #endif

 int main(int argc, char* argv[]) {
+#ifdef __linux__
+  // Run before GUI, configuration, logging or daemon initialization. The
+  // guard owns native privacy resources and restores them if this app exits.
+  if (argc == 2 &&
+      std::strcmp(argv[1], crossdesk::kLinuxPrivacyGuardArgument) == 0) {
+    return crossdesk::RunLinuxPrivacyGuard();
+  }
+#endif
+#ifdef _WIN32
+  if (argc == 2 &&
+      std::strcmp(argv[1], crossdesk::kSlintRendererProbeArgument) == 0) {
+    return crossdesk::RunSlintRendererProbe();
+  }
+#endif
+
+  // Service operations and config migration can log before the GUI starts.
+  // Configure the directory first, including CLI and daemon child paths.
+  auto path_manager = std::make_unique<crossdesk::PathManager>("CrossDesk");
+  crossdesk::InitLogger(path_manager->GetLogPath().string());
+
 #ifdef _WIN32
  if (argc > 1 && IsServiceCliCommand(argv[1])) {
    return HandleServiceCliCommand(argv[1]);
@@ -201,7 +227,6 @@ int main(int argc, char* argv[]) {
 #endif

  bool enable_daemon = false;
-  auto path_manager = std::make_unique<crossdesk::PathManager>("CrossDesk");
  if (path_manager) {
    std::string cache_path = path_manager->GetCachePath().string();
    crossdesk::ConfigCenter config_center(cache_path + "/config.ini");
@@ -228,4 +253,4 @@ int main(int argc, char* argv[]) {
  crossdesk::Render render;
  render.Run();
  return 0;
-}
+}
@@ -0,0 +1,21 @@
+#include "autostart.h"
+
+#include "platform/autostart_backend.h"
+
+namespace crossdesk {
+
+bool EnableAutostart(const std::string& app_name) {
+  const std::string executable_path = platform::GetAutostartExecutablePath();
+  return !executable_path.empty() &&
+         platform::EnableAutostart(app_name, executable_path);
+}
+
+bool DisableAutostart(const std::string& app_name) {
+  return platform::DisableAutostart(app_name);
+}
+
+bool IsAutostartEnabled(const std::string& app_name) {
+  return platform::IsAutostartEnabled(app_name);
+}
+
+}  // namespace crossdesk
@@ -7,7 +7,7 @@
 #ifndef _PLATFORM_H_
 #define _PLATFORM_H_

-#include <iostream>
+#include <string>

 namespace crossdesk {

@@ -1,5 +1,7 @@
 #include "shared_cursor_state.h"

+#include <remote_action.h>
+
 #include <mutex>

 namespace crossdesk {
@@ -3,7 +3,7 @@

 #include <cstdint>

-#include "remote_cursor_shape.h"
+#include <remote_cursor_shape.h>

 namespace crossdesk {

@@ -0,0 +1,79 @@
+#include "task_queue_lock_free.h"
+
+#include <exception>
+#include <new>
+#include <stdexcept>
+#include <utility>
+
+namespace crossdesk {
+
+TaskQueueLockFree::TaskQueueLockFree()
+    : producer_(task_queue_), worker_([this] { WorkerThread(); }) {}
+
+TaskQueueLockFree::~TaskQueueLockFree() { Stop(); }
+
+std::future<void> TaskQueueLockFree::PostTask(std::function<void()> task) {
+  TaskItem item;
+  item.run = std::move(task);
+  auto result = item.completion.get_future();
+  {
+    std::lock_guard lock(mutex_);
+    if (stopping_) {
+      throw std::runtime_error("Cannot post to a stopped task queue");
+    }
+
+    // Count before publishing: the worker may dequeue as soon as enqueue returns.
+    ++pending_tasks_;
+    if (!task_queue_.enqueue(producer_, std::move(item))) {
+      --pending_tasks_;
+      throw std::bad_alloc();
+    }
+  }
+  wake_.notify_one();
+  return result;
+}
+
+void TaskQueueLockFree::Stop() {
+  // Concurrent Stop callers all wait for the same worker shutdown to finish.
+  std::call_once(stop_once_, [this] {
+    {
+      std::lock_guard lock(mutex_);
+      stopping_ = true;
+    }
+    wake_.notify_all();
+    worker_.join();
+  });
+}
+
+void TaskQueueLockFree::WorkerThread() {
+  while (true) {
+    TaskItem item;
+    while (task_queue_.try_dequeue(item)) {
+      --pending_tasks_;
+
+      std::exception_ptr error;
+      try {
+        item.run();
+      } catch (...) {
+        error = std::current_exception();
+      }
+
+      // Release captured resources before marking the task complete.
+      item.run = nullptr;
+      if (error) {
+        item.completion.set_exception(error);
+      } else {
+        item.completion.set_value();
+      }
+    }
+
+    std::unique_lock lock(mutex_);
+    wake_.wait(lock, [this] { return stopping_ || pending_tasks_ > 0; });
+    // A stop request must not discard tasks submitted while the worker was idle.
+    if (stopping_ && pending_tasks_ == 0) {
+      return;
+    }
+  }
+}
+
+}  // namespace crossdesk
@@ -0,0 +1,57 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-07
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _TASK_QUEUE_LOCK_FREE_H_
+#define _TASK_QUEUE_LOCK_FREE_H_
+
+#include <atomic>
+#include <condition_variable>
+#include <cstddef>
+#include <functional>
+#include <future>
+#include <mutex>
+#include <thread>
+
+#include <concurrentqueue.h>
+
+namespace crossdesk {
+
+// A single worker executes tasks in submission order. The concurrent queue
+// stores tasks; a mutex coordinates submissions, worker wakeups and shutdown.
+class TaskQueueLockFree {
+ public:
+  TaskQueueLockFree();
+  ~TaskQueueLockFree();
+
+  // Returns completion or the task's exception. Throws if the queue is stopped.
+  std::future<void> PostTask(std::function<void()> task);
+
+  // Rejects new tasks, finishes accepted tasks and joins the worker.
+  // May be called repeatedly, but never from the queue's own tasks.
+  void Stop();
+
+ private:
+  struct TaskItem {
+    std::function<void()> run;
+    std::promise<void> completion;
+  };
+
+  void WorkerThread();
+
+  moodycamel::ConcurrentQueue<TaskItem> task_queue_;
+  // All submissions share one producer so different caller threads keep FIFO.
+  moodycamel::ProducerToken producer_;
+  std::atomic<std::size_t> pending_tasks_{0};
+  std::mutex mutex_;
+  std::condition_variable wake_;
+  bool stopping_ = false;
+  std::once_flag stop_once_;
+  std::thread worker_;
+};
+
+}  // namespace crossdesk
+
+#endif
@@ -12,6 +12,12 @@ bool IsValidTurnModeValue(long value) {
         value <= static_cast<long>(ConfigCenter::TURN_MODE::FORCE_TCP);
 }

+bool IsValidVideoAdaptationPolicyValue(long value) {
+  using Policy = ConfigCenter::VIDEO_ADAPTATION_POLICY;
+  return value >= static_cast<long>(Policy::FRAME_RATE_PRIORITY) &&
+         value <= static_cast<long>(Policy::BALANCED);
+}
+
 }  // namespace

 ConfigCenter::ConfigCenter(const std::string& config_path)
@@ -52,6 +58,26 @@ int ConfigCenter::Load() {
  video_frame_rate_ = static_cast<VIDEO_FRAME_RATE>(ini_.GetLongValue(
      section_, "video_frame_rate", static_cast<long>(video_frame_rate_)));

+  const long screen_capture_method_value = ini_.GetLongValue(
+      section_, "screen_capture_method",
+      static_cast<long>(ScreenCaptureMethod::Auto));
+  screen_capture_method_ = IsValidScreenCaptureMethod(screen_capture_method_value)
+                               ? static_cast<ScreenCaptureMethod>(
+                                     screen_capture_method_value)
+                               : ScreenCaptureMethod::Auto;
+
+  const long video_adaptation_policy_value = ini_.GetLongValue(
+      section_, "video_adaptation_policy",
+      static_cast<long>(video_adaptation_policy_));
+  if (IsValidVideoAdaptationPolicyValue(video_adaptation_policy_value)) {
+    video_adaptation_policy_ =
+        static_cast<VIDEO_ADAPTATION_POLICY>(video_adaptation_policy_value);
+  } else {
+    LOG_WARN("Invalid video adaptation policy [{}], using quality priority",
+             video_adaptation_policy_value);
+    video_adaptation_policy_ = VIDEO_ADAPTATION_POLICY::QUALITY_PRIORITY;
+  }
+
  video_encode_format_ = static_cast<VIDEO_ENCODE_FORMAT>(
      ini_.GetLongValue(section_, "video_encode_format",
                        static_cast<long>(video_encode_format_)));
@@ -77,7 +103,12 @@ int ConfigCenter::Load() {
    ini_.SetLongValue(section_, "turn_mode", static_cast<long>(turn_mode_));
    persist_config_migration = true;
  }
-  enable_srtp_ = ini_.GetBoolValue(section_, "enable_srtp", enable_srtp_);
+  // Migrate the former user switch. Keep true in the file for older builds,
+  // while the current application always requests encrypted native media.
+  if (!ini_.GetBoolValue(section_, "enable_srtp", false)) {
+    ini_.SetBoolValue(section_, "enable_srtp", true);
+    persist_config_migration = true;
+  }
  enable_self_hosted_ =
      ini_.GetBoolValue(section_, "enable_self_hosted", enable_self_hosted_);

@@ -98,19 +129,11 @@ int ConfigCenter::Load() {
  } else {
    signal_server_port_ = 0;
  }
-  const char* coturn_server_port_value =
-      ini_.GetValue(section_, "coturn_server_port", nullptr);
-  if (coturn_server_port_value != nullptr &&
-      strlen(coturn_server_port_value) > 0) {
-    coturn_server_port_ =
-        static_cast<int>(ini_.GetLongValue(section_, "coturn_server_port", 0));
-  } else {
-    coturn_server_port_ = 0;
-  }
-
  enable_autostart_ =
      ini_.GetBoolValue(section_, "enable_autostart", enable_autostart_);
  enable_daemon_ = ini_.GetBoolValue(section_, "enable_daemon", enable_daemon_);
+  enable_privacy_screen_.store(
+      ini_.GetBoolValue(section_, "enable_privacy_screen", true));
  portable_service_prompt_suppressed_ =
      ini_.GetBoolValue(section_, "portable_service_prompt_suppressed",
                        portable_service_prompt_suppressed_);
@@ -137,13 +160,17 @@ int ConfigCenter::Save() {
                    static_cast<long>(video_quality_));
  ini_.SetLongValue(section_, "video_frame_rate",
                    static_cast<long>(video_frame_rate_));
+  ini_.SetLongValue(section_, "screen_capture_method",
+                    static_cast<long>(screen_capture_method_));
+  ini_.SetLongValue(section_, "video_adaptation_policy",
+                    static_cast<long>(video_adaptation_policy_));
  ini_.SetLongValue(section_, "video_encode_format",
                    static_cast<long>(video_encode_format_));
  ini_.SetBoolValue(section_, "hardware_video_codec", hardware_video_codec_);
  ini_.SetLongValue(section_, "turn_mode", static_cast<long>(turn_mode_));
  ini_.SetBoolValue(section_, "enable_turn",
                    turn_mode_ != TURN_MODE::DISABLED);
-  ini_.SetBoolValue(section_, "enable_srtp", enable_srtp_);
+  ini_.SetBoolValue(section_, "enable_srtp", true);
  ini_.SetBoolValue(section_, "enable_self_hosted", enable_self_hosted_);

  // only save when self hosted
@@ -151,12 +178,12 @@ int ConfigCenter::Save() {
    ini_.SetValue(section_, "signal_server_host", signal_server_host_.c_str());
    ini_.SetLongValue(section_, "signal_server_port",
                      static_cast<long>(signal_server_port_));
-    ini_.SetLongValue(section_, "coturn_server_port",
-                      static_cast<long>(coturn_server_port_));
  }

  ini_.SetBoolValue(section_, "enable_autostart", enable_autostart_);
  ini_.SetBoolValue(section_, "enable_daemon", enable_daemon_);
+  ini_.SetBoolValue(section_, "enable_privacy_screen",
+                    enable_privacy_screen_.load());
  ini_.SetBoolValue(section_, "portable_service_prompt_suppressed",
                    portable_service_prompt_suppressed_);

@@ -205,6 +232,32 @@ int ConfigCenter::SetVideoFrameRate(VIDEO_FRAME_RATE video_frame_rate) {
  return 0;
 }

+int ConfigCenter::SetScreenCaptureMethod(ScreenCaptureMethod method) {
+  if (!IsValidScreenCaptureMethod(static_cast<long>(method))) {
+    return -1;
+  }
+  ini_.SetLongValue(section_, "screen_capture_method", static_cast<long>(method));
+  if (ini_.SaveFile(config_path_.c_str()) < 0) {
+    ini_.SetLongValue(section_, "screen_capture_method",
+                      static_cast<long>(screen_capture_method_));
+    return -1;
+  }
+  screen_capture_method_ = method;
+  return 0;
+}
+
+int ConfigCenter::SetVideoAdaptationPolicy(
+    VIDEO_ADAPTATION_POLICY policy) {
+  video_adaptation_policy_ = policy;
+  ini_.SetLongValue(section_, "video_adaptation_policy",
+                    static_cast<long>(video_adaptation_policy_));
+  SI_Error rc = ini_.SaveFile(config_path_.c_str());
+  if (rc < 0) {
+    return -1;
+  }
+  return 0;
+}
+
 int ConfigCenter::SetVideoEncodeFormat(
    VIDEO_ENCODE_FORMAT video_encode_format) {
  video_encode_format_ = video_encode_format;
@@ -253,16 +306,6 @@ int ConfigCenter::SetTurn(bool enable_turn) {
  return SetTurnMode(turn_mode_);
 }

-int ConfigCenter::SetSrtp(bool enable_srtp) {
-  enable_srtp_ = enable_srtp;
-  ini_.SetBoolValue(section_, "enable_srtp", enable_srtp_);
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
-  return 0;
-}
-
 int ConfigCenter::SetServerHost(const std::string& signal_server_host) {
  signal_server_host_ = signal_server_host;
  ini_.SetValue(section_, "signal_server_host", signal_server_host_.c_str());
@@ -284,17 +327,6 @@ int ConfigCenter::SetServerPort(int signal_server_port) {
  return 0;
 }

-int ConfigCenter::SetCoturnServerPort(int coturn_server_port) {
-  coturn_server_port_ = coturn_server_port;
-  ini_.SetLongValue(section_, "coturn_server_port",
-                    static_cast<long>(coturn_server_port_));
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
-  return 0;
-}
-
 int ConfigCenter::SetSelfHosted(bool enable_self_hosted) {
  enable_self_hosted_ = enable_self_hosted;
  ini_.SetBoolValue(section_, "enable_self_hosted", enable_self_hosted_);
@@ -314,19 +346,9 @@ int ConfigCenter::SetSelfHosted(bool enable_self_hosted) {
      signal_server_port_ = static_cast<int>(
          ini_.GetLongValue(section_, "signal_server_port", 0));
    }
-    const char* coturn_server_port_value =
-        ini_.GetValue(section_, "coturn_server_port", nullptr);
-    if (coturn_server_port_value != nullptr &&
-        strlen(coturn_server_port_value) > 0) {
-      coturn_server_port_ = static_cast<int>(
-          ini_.GetLongValue(section_, "coturn_server_port", 0));
-    }
-
    ini_.SetValue(section_, "signal_server_host", signal_server_host_.c_str());
    ini_.SetLongValue(section_, "signal_server_port",
                      static_cast<long>(signal_server_port_));
-    ini_.SetLongValue(section_, "coturn_server_port",
-                      static_cast<long>(coturn_server_port_));
  }

  SI_Error rc = ini_.SaveFile(config_path_.c_str());
@@ -371,6 +393,21 @@ int ConfigCenter::SetDaemon(bool enable_daemon) {
  return 0;
 }

+int ConfigCenter::SetPrivacyScreen(bool enable_privacy_screen) {
+  const bool previous = enable_privacy_screen_.load();
+  if (previous == enable_privacy_screen) return 0;
+  ini_.SetBoolValue(section_, "enable_privacy_screen", enable_privacy_screen);
+  if (ini_.SaveFile(config_path_.c_str()) < 0) {
+    ini_.SetBoolValue(section_, "enable_privacy_screen", previous);
+    LOG_ERROR("Failed to save automatic privacy screen preference");
+    return -1;
+  }
+  // RTC callbacks read only the value committed by the settings thread.
+  enable_privacy_screen_.store(enable_privacy_screen);
+  LOG_INFO("Privacy screen on incoming connection: {}", enable_privacy_screen);
+  return 0;
+}
+
 int ConfigCenter::SetPortableServicePromptSuppressed(bool suppressed) {
  portable_service_prompt_suppressed_ = suppressed;
  ini_.SetBoolValue(section_, "portable_service_prompt_suppressed",
@@ -395,12 +432,31 @@ ConfigCenter::VIDEO_FRAME_RATE ConfigCenter::GetVideoFrameRate() const {
  return video_frame_rate_;
 }

+ScreenCaptureMethod ConfigCenter::GetScreenCaptureMethod() const {
+  return screen_capture_method_;
+}
+
+ConfigCenter::VIDEO_ADAPTATION_POLICY
+ConfigCenter::GetVideoAdaptationPolicy() const {
+  return video_adaptation_policy_;
+}
+
 ConfigCenter::VIDEO_ENCODE_FORMAT ConfigCenter::GetVideoEncodeFormat() const {
  return video_encode_format_;
 }

+bool ConfigCenter::IsHardwareVideoCodecAvailable() {
+#if (((defined(_WIN32) || defined(__linux__)) && !defined(__aarch64__) && \
+      !defined(__arm__) && USE_CUDA) ||                                   \
+     defined(__APPLE__))
+  return true;
+#else
+  return false;
+#endif
+}
+
 bool ConfigCenter::IsHardwareVideoCodec() const {
-  return hardware_video_codec_;
+  return IsHardwareVideoCodecAvailable() && hardware_video_codec_;
 }

 ConfigCenter::TURN_MODE ConfigCenter::GetTurnMode() const {
@@ -411,7 +467,7 @@ bool ConfigCenter::IsEnableTurn() const {
  return turn_mode_ != TURN_MODE::DISABLED;
 }

-bool ConfigCenter::IsEnableSrtp() const { return enable_srtp_; }
+bool ConfigCenter::IsEnableSrtp() const { return true; }

 std::string ConfigCenter::GetSignalServerHost() const {
  return signal_server_host_;
@@ -419,8 +475,6 @@ std::string ConfigCenter::GetSignalServerHost() const {

 int ConfigCenter::GetSignalServerPort() const { return signal_server_port_; }

-int ConfigCenter::GetCoturnServerPort() const { return coturn_server_port_; }
-
 std::string ConfigCenter::GetDefaultServerHost() const {
  return signal_server_host_default_;
 }
@@ -429,16 +483,16 @@ int ConfigCenter::GetDefaultSignalServerPort() const {
  return server_port_default_;
 }

-int ConfigCenter::GetDefaultCoturnServerPort() const {
-  return coturn_server_port_default_;
-}
-
 bool ConfigCenter::IsSelfHosted() const { return enable_self_hosted_; }

 bool ConfigCenter::IsEnableAutostart() const { return enable_autostart_; }

 bool ConfigCenter::IsEnableDaemon() const { return enable_daemon_; }

+bool ConfigCenter::IsEnablePrivacyScreen() const {
+  return enable_privacy_screen_.load();
+}
+
 bool ConfigCenter::IsPortableServicePromptSuppressed() const {
  return portable_service_prompt_suppressed_;
 }
@@ -7,9 +7,11 @@
 #ifndef _CONFIG_CENTER_H_
 #define _CONFIG_CENTER_H_

+#include <atomic>
 #include <string>

 #include "SimpleIni.h"
+#include "screen_capturer/screen_capture_method.h"

 namespace crossdesk {

@@ -18,6 +20,11 @@ class ConfigCenter {
  enum class LANGUAGE { CHINESE = 0, ENGLISH = 1, RUSSIAN = 2 };
  enum class VIDEO_QUALITY { LOW = 0, MEDIUM = 1, HIGH = 2 };
  enum class VIDEO_FRAME_RATE { FPS_30 = 0, FPS_60 = 1 };
+  enum class VIDEO_ADAPTATION_POLICY {
+    FRAME_RATE_PRIORITY = 0,
+    QUALITY_PRIORITY = 1,
+    BALANCED = 2
+  };
  enum class VIDEO_ENCODE_FORMAT { H264 = 0, AV1 = 1 };
  enum class TURN_MODE {
    DISABLED = 0,
@@ -34,17 +41,18 @@ class ConfigCenter {
  int SetLanguage(LANGUAGE language);
  int SetVideoQuality(VIDEO_QUALITY video_quality);
  int SetVideoFrameRate(VIDEO_FRAME_RATE video_frame_rate);
+  int SetScreenCaptureMethod(ScreenCaptureMethod method);
+  int SetVideoAdaptationPolicy(VIDEO_ADAPTATION_POLICY policy);
  int SetVideoEncodeFormat(VIDEO_ENCODE_FORMAT video_encode_format);
  int SetHardwareVideoCodec(bool hardware_video_codec);
  int SetTurnMode(TURN_MODE turn_mode);
  int SetTurn(bool enable_turn);
-  int SetSrtp(bool enable_srtp);
  int SetServerHost(const std::string& signal_server_host);
  int SetServerPort(int signal_server_port);
-  int SetCoturnServerPort(int coturn_server_port);
  int SetSelfHosted(bool enable_self_hosted);
  int SetAutostart(bool enable_autostart);
  int SetDaemon(bool enable_daemon);
+  int SetPrivacyScreen(bool enable_privacy_screen);
  int SetPortableServicePromptSuppressed(bool suppressed);
  int SetFileTransferSavePath(const std::string& path);

@@ -53,20 +61,23 @@ class ConfigCenter {
  LANGUAGE GetLanguage() const;
  VIDEO_QUALITY GetVideoQuality() const;
  VIDEO_FRAME_RATE GetVideoFrameRate() const;
+  ScreenCaptureMethod GetScreenCaptureMethod() const;
+  VIDEO_ADAPTATION_POLICY GetVideoAdaptationPolicy() const;
  VIDEO_ENCODE_FORMAT GetVideoEncodeFormat() const;
+  // Whether this build includes a hardware video codec backend.
+  static bool IsHardwareVideoCodecAvailable();
  bool IsHardwareVideoCodec() const;
  TURN_MODE GetTurnMode() const;
  bool IsEnableTurn() const;
  bool IsEnableSrtp() const;
  std::string GetSignalServerHost() const;
  int GetSignalServerPort() const;
-  int GetCoturnServerPort() const;
  std::string GetDefaultServerHost() const;
  int GetDefaultSignalServerPort() const;
-  int GetDefaultCoturnServerPort() const;
  bool IsSelfHosted() const;
  bool IsEnableAutostart() const;
  bool IsEnableDaemon() const;
+  bool IsEnablePrivacyScreen() const;
  bool IsPortableServicePromptSuppressed() const;
  std::string GetFileTransferSavePath() const;

@@ -81,19 +92,20 @@ class ConfigCenter {
  LANGUAGE language_ = LANGUAGE::CHINESE;
  VIDEO_QUALITY video_quality_ = VIDEO_QUALITY::HIGH;
  VIDEO_FRAME_RATE video_frame_rate_ = VIDEO_FRAME_RATE::FPS_60;
+  ScreenCaptureMethod screen_capture_method_ = ScreenCaptureMethod::Auto;
+  VIDEO_ADAPTATION_POLICY video_adaptation_policy_ =
+      VIDEO_ADAPTATION_POLICY::QUALITY_PRIORITY;
  VIDEO_ENCODE_FORMAT video_encode_format_ = VIDEO_ENCODE_FORMAT::H264;
  bool hardware_video_codec_ = false;
  TURN_MODE turn_mode_ = TURN_MODE::AUTO_UDP_TCP;
-  bool enable_srtp_ = false;
  std::string signal_server_host_ = "";
  std::string signal_server_host_default_ = "api.crossdesk.cn";
  int signal_server_port_ = 0;
  int server_port_default_ = 9099;
-  int coturn_server_port_ = 0;
-  int coturn_server_port_default_ = 3478;
  bool enable_self_hosted_ = false;
  bool enable_autostart_ = false;
  bool enable_daemon_ = false;
+  std::atomic<bool> enable_privacy_screen_{true};
  bool portable_service_prompt_suppressed_ = false;
  std::string file_transfer_save_path_ = "";
 };
@@ -0,0 +1,55 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2023-12-14
+ * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _DEVICE_CONTROLLER_H_
+#define _DEVICE_CONTROLLER_H_
+
+#include <cstdint>
+#include <vector>
+
+#include <remote_action.h>
+
+#include "display_info.h"
+
+namespace crossdesk {
+
+// int key_code, bool is_down, uint32_t scan_code, bool extended
+using OnKeyAction = void (*)(int, bool, uint32_t, bool, void*);
+
+class DeviceController {
+ public:
+  virtual ~DeviceController() = default;
+};
+
+class MouseController : public DeviceController {
+ public:
+  ~MouseController() override = default;
+
+  virtual int Init(std::vector<DisplayInfo> display_info_list) = 0;
+  virtual int Destroy() = 0;
+  virtual int SendMouseCommand(RemoteAction remote_action,
+                               int display_index) = 0;
+  virtual void UpdateDisplayInfoList(
+      const std::vector<DisplayInfo>&) {}
+};
+
+class KeyboardCapturer : public DeviceController {
+ public:
+  ~KeyboardCapturer() override = default;
+
+  virtual int Hook(OnKeyAction on_key_action, void* user_ptr) = 0;
+  virtual int Unhook() = 0;
+  // Backends with an asynchronous capture loop override this so the UI can
+  // fall back to window events if that loop stops unexpectedly.
+  virtual bool IsHookActive() const { return true; }
+  virtual int SendKeyboardCommand(int key_code, bool is_down,
+                                  uint32_t scan_code = 0,
+                                  bool extended = false) = 0;
+};
+
+}  // namespace crossdesk
+
+#endif
@@ -8,8 +8,6 @@
 #define _DEVICE_CONTROLLER_FACTORY_H_

 #include "device_controller.h"
-#include "keyboard_capturer.h"
-#include "mouse_controller.h"

 namespace crossdesk {

@@ -21,16 +19,7 @@ class DeviceControllerFactory {
  virtual ~DeviceControllerFactory() {}

 public:
-  DeviceController* Create(Device device) {
-    switch (device) {
-      case Mouse:
-        return new MouseController();
-      case Keyboard:
-        return new KeyboardCapturer();
-      default:
-        return nullptr;
-    }
-  }
+  DeviceController* Create(Device device);
 };
 }  // namespace crossdesk
-#endif
+#endif
@@ -1,5 +1,11 @@
-#ifndef CROSSDESK_GUI_APPLICATION_STATE_H_
-#define CROSSDESK_GUI_APPLICATION_STATE_H_
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-04
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _APPLICATION_STATE_H_
+#define _APPLICATION_STATE_H_

 #include <atomic>
 #include <chrono>
@@ -60,10 +66,7 @@ struct InteractionState {
  bool mouse_controller_is_started_ = false;
  bool start_screen_capturer_ = false;
  bool screen_capturer_is_started_ = false;
-  bool start_speaker_capturer_ = false;
-  bool speaker_capturer_is_started_ = false;
  bool start_keyboard_capturer_ = false;
-  bool show_cursor_ = false;
  bool keyboard_capturer_is_started_ = false;
  bool keyboard_capturer_uses_window_events_ = false;
  bool foucs_on_main_window_ = false;
@@ -192,4 +195,4 @@ struct ApplicationState : MainWindowState,

 }  // namespace crossdesk::gui_detail

-#endif  // CROSSDESK_GUI_APPLICATION_STATE_H_
+#endif
@@ -1,5 +1,7 @@
 #include "application/gui_application.h"

+#include <remote_action.h>
+
 #include <SDL3/SDL.h>
 #include <slint.h>
 #include <tinyfiledialogs.h>
@@ -22,6 +24,7 @@
 #include <string>
 #include <string_view>
 #include <unordered_map>
+#include <unordered_set>
 #include <utility>
 #include <vector>

@@ -31,12 +34,15 @@
 #include "platform.h"
 #include "platform/video_renderer.h"
 #include "rendering/slint_video_presenter.h"
+#include "runtime/privacy_control_state.h"
 #if _WIN32
 #include <windows.h>

-#include "platform/tray/win_tray.h"
+#include "platform/windows/gui/slint_backend.h"
+#include "platform/windows/gui/tray/win_tray.h"
+#include "platform/windows/gui/window_icons.h"
 #elif defined(__APPLE__)
-#include "platform/tray/mac_tray.h"
+#include "platform/macos/gui/tray/mac_tray.h"
 #include "platform/window_drag.h"
 #elif defined(__linux__)
 #include <GL/gl.h>
@@ -44,7 +50,8 @@
 #include <X11/Xlib.h>
 #include <unistd.h>

-#include "platform/tray/linux_tray.h"
+#include "platform/linux/gui/cuda_graphics.h"
+#include "platform/linux/gui/tray/linux_tray.h"
 #endif
 #include "rd_log.h"
 #include "server_window_state.h"
@@ -944,10 +951,10 @@ int GuiApplication::Run() {
  }
  exec_log_path_ = path_manager_->GetLogPath().string();
  dll_log_path_ = exec_log_path_;
+  InitializeLogger();
  cache_path_ = path_manager_->GetCachePath().string();
  config_center_ = std::make_unique<ConfigCenter>(cache_path_ + "/config.ini");

-  InitializeLogger();
  LOG_INFO("CrossDesk version: {} (Slint UI)", CROSSDESK_VERSION);

  strncpy(signal_server_ip_self_, config_center_->GetSignalServerHost().c_str(),
@@ -989,6 +996,15 @@ int GuiApplication::Run() {
  if (!InitializeSDL()) {
    return -1;
  }
+#if _WIN32
+  const auto backend = ConfigureWindowsSlintBackend();
+  if (!backend.success) {
+    LOG_ERROR("{}", backend.diagnostic);
+    SDL_Quit();
+    return -1;
+  }
+  LOG_INFO("Slint backend: {}; {}", backend.backend, backend.diagnostic);
+#endif
  InitializeModules();
  InitializeUi();

@@ -998,6 +1014,9 @@ int GuiApplication::Run() {
  // when deciding whether the last hidden window should stop the event loop.
  // Keep the loop alive until the tray's explicit Exit action requests quit.
  ui_->main->show();
+#if _WIN32
+  ConfigureWindowsWindowIcons(ui_->main->window().win32_hwnd());
+#endif
  slint::run_event_loop(slint::EventLoopMode::RunUntilQuit);
  Cleanup();
  return 0;
@@ -1013,10 +1032,13 @@ void GuiApplication::InitializeSettings() {
  language_button_value_ = localization_language_index_;
  localization_language_ =
      static_cast<ConfigCenter::LANGUAGE>(localization_language_index_);
+  privacy_.SetText({
+      localization::privacy_screen_unlock_hint[localization_language_index_]});
 }

 bool GuiApplication::InitializeSDL() {
 #if defined(__linux__) && !defined(__APPLE__)
+  ConfigureLinuxCudaGraphics(config_center_->IsHardwareVideoCodec());
  // Standard Wayland top-level windows cannot choose an absolute screen
  // position. Use the session's XWayland compatibility server for the GUI so
  // auxiliary windows such as the controlled-side status window can be
@@ -1096,6 +1118,9 @@ void GuiApplication::InitializeUi() {
    wayland_display_guard.emplace("WAYLAND_DISPLAY");
    wayland_socket_guard.emplace("WAYLAND_SOCKET");
  }
+  // Match crossdesk.desktop even when the Debian launcher runs crossdesk-bin.
+  // Set this before creating any windows so X11 and Wayland share the same id.
+  slint::set_xdg_app_id("crossdesk");
 #endif
  ui_ = std::make_unique<SlintUi>();
  ui_->video_presenter =
@@ -1134,8 +1159,12 @@ void GuiApplication::InitializeSystemTray() {
      return;
    }
    ui_->main->show();
+#if _WIN32
+    ConfigureWindowsWindowIcons(ui_->main->window().win32_hwnd());
+#endif
    ui_->main->window().set_minimized(false);
 #if defined(__APPLE__)
+    MacActivateWindow(ui_->main->window().appkit_view());
    // A window restored from the tray may only obtain its NSWindow after the
    // callback returns, so let the regular UI tick configure it.
    ui_->main_native_titlebar_attempts = 30;
@@ -1146,16 +1175,12 @@ void GuiApplication::InitializeSystemTray() {
      ui_->main->hide();
    }
  };
-  auto open_settings = [this] {
+  auto open_settings = [this, show_window] {
    if (!ui_) {
      return;
    }
-    ui_->main->show();
-    ui_->main->window().set_minimized(false);
+    show_window();
    ui_->main->set_settings_open(true);
-#if defined(__APPLE__)
-    ui_->main_native_titlebar_attempts = 30;
-#endif
  };
  auto exit_app = [this] {
    exit_ = true;
@@ -1203,17 +1228,33 @@ void GuiApplication::ResetSettingsUi() {
  ui_->main->set_language_index(language_button_value_);
  ui_->main->set_video_quality_index(video_quality_button_value_);
  ui_->main->set_frame_rate_index(video_frame_rate_button_value_);
+  ui_->main->set_adaptation_policy_index(
+      video_adaptation_policy_button_value_);
  ui_->main->set_codec_index(video_encode_format_button_value_);
-  ui_->main->set_hardware_codec_enabled(enable_hardware_video_codec_);
+  const bool hardware_codec_available =
+      ConfigCenter::IsHardwareVideoCodecAvailable();
+  ui_->main->set_hardware_codec_available(hardware_codec_available);
+  ui_->main->set_hardware_codec_enabled(hardware_codec_available &&
+                                       enable_hardware_video_codec_);
  ui_->main->set_turn_enabled(enable_turn_);
-  ui_->main->set_srtp_enabled(enable_srtp_);
  ui_->main->set_self_hosted_enabled(enable_self_hosted_);
  ui_->main->set_autostart_enabled(enable_autostart_);
  ui_->main->set_daemon_enabled(enable_daemon_);
+  ui_->main->set_privacy_on_connect_enabled(
+      config_center_->IsEnablePrivacyScreen());
+#ifdef _WIN32
+  ui_->main->set_capture_method_visible(true);
+  ui_->main->set_capture_method_index(
+      static_cast<int>(config_center_->GetScreenCaptureMethod()));
+#endif
+#if defined(_WIN32) || defined(__APPLE__) || defined(__linux__)
+  ui_->main->set_privacy_setting_available(true);
+#else
+  ui_->main->set_privacy_setting_available(false);
+#endif
  ui_->main->set_file_save_path(file_transfer_save_path_buf_);
  ui_->main->set_server_host(signal_server_ip_self_);
  ui_->main->set_server_port(signal_server_port_self_);
-  ui_->main->set_coturn_port(coturn_server_port_self_);
 }

 void GuiApplication::BindMainCallbacks() {
@@ -1371,7 +1412,6 @@ void GuiApplication::BindMainCallbacks() {
  main->on_save_self_hosted_settings([this] {
    const std::string host(ui_->main->get_server_host());
    const auto signal_port = ParsePort(ui_->main->get_server_port());
-    const auto coturn_port = ParsePort(ui_->main->get_coturn_port());
    if (!host.empty()) {
      config_center_->SetServerHost(host);
      std::memset(signal_server_ip_self_, 0, sizeof(signal_server_ip_self_));
@@ -1388,25 +1428,14 @@ void GuiApplication::BindMainCallbacks() {
      std::snprintf(signal_server_port_, sizeof(signal_server_port_), "%d",
                    *signal_port);
    }
-    if (coturn_port) {
-      config_center_->SetCoturnServerPort(*coturn_port);
-      std::snprintf(coturn_server_port_self_, sizeof(coturn_server_port_self_),
-                    "%d", *coturn_port);
-      std::snprintf(coturn_server_port_, sizeof(coturn_server_port_), "%d",
-                    *coturn_port);
-    }
  });
  main->on_cancel_self_hosted_settings([this] {
    const std::string host = config_center_->GetSignalServerHost();
    ui_->main->set_server_host(UiText(host));
    const int signal_port = config_center_->GetSignalServerPort();
-    const int coturn_port = config_center_->GetCoturnServerPort();
    ui_->main->set_server_port(signal_port > 0
                                   ? UiText(std::to_string(signal_port))
                                   : slint::SharedString{});
-    ui_->main->set_coturn_port(coturn_port > 0
-                                   ? UiText(std::to_string(coturn_port))
-                                   : slint::SharedString{});
  });
  main->on_open_download([this] { OpenUrl("https://crossdesk.cn"); });
  main->on_connection_cancel([this] {
@@ -1562,6 +1591,10 @@ void GuiApplication::BindStreamCallbacks() {
      return;
    }
    props->selected_display_ = index;
+    {
+      std::lock_guard lock(props->remote_cursor_state_mutex_);
+      props->cursor_presentation_ = {};
+    }
    RemoteAction action{};
    action.type = ControlType::display_id;
    action.d = index;
@@ -1583,6 +1616,36 @@ void GuiApplication::BindStreamCallbacks() {
    SendReliableDataFrame(props->peer_, message.c_str(), message.size(),
                          props->control_data_label_.c_str());
  });
+  stream->on_toggle_privacy([this] {
+    auto props = SelectedSession();
+    if (!props || !props->peer_ || !props->control_mouse_ ||
+        props->connection_status_.load() != ConnectionStatus::Connected) return;
+    RemoteAction action{};
+    action.type = ControlType::privacy_command;
+    {
+      std::lock_guard lock(props->privacy_status_mutex_);
+      const auto& status = props->privacy_status_;
+      const uint64_t now = SDL_GetTicks();
+      const auto controls = GetPrivacyControlState(
+          status, props->privacy_status_received_, props->privacy_command_pending_,
+          now - props->privacy_status_tick_, now - props->privacy_command_tick_);
+      if (!controls.can_toggle) return;
+      action.pc.flag = controls.active ? PrivacyCommandFlag::disable
+                                      : PrivacyCommandFlag::enable;
+      action.pc.block_local_input = true;
+      props->privacy_command_pending_ = true;
+      props->privacy_command_tick_ = now;
+      props->privacy_request_revision_ = status.revision;
+    }
+    const auto message = action.to_json();
+    if (SendReliableDataFrame(props->peer_, message.data(), message.size(),
+                              props->control_data_label_.c_str()) != 0) {
+      std::lock_guard lock(props->privacy_status_mutex_);
+      props->privacy_command_pending_ = false;
+      props->privacy_status_received_ = false;
+      LOG_WARN("Privacy command send failed, remote_id={}", props->remote_id_);
+    }
+  });
  stream->on_toggle_mouse_control([this] {
    auto props = SelectedSession();
    if (!props || !props->connection_established_) {
@@ -1592,6 +1655,7 @@ void GuiApplication::BindStreamCallbacks() {
    props->enable_mouse_control_ = props->control_mouse_;
    start_keyboard_capturer_ = props->control_mouse_;
    if (!props->control_mouse_) {
+      devices_.StopKeyboardCapturer();
      keyboard_.ForceReleasePressedKeys();
    }
  });
@@ -1723,7 +1787,7 @@ void GuiApplication::BindServerCallbacks() {
  });
  server->on_disconnect_controller([this] {
    if (peer_ && !selected_server_remote_id_.empty()) {
-      LeaveConnection(peer_, selected_server_remote_id_.c_str());
+      CloseServerController(selected_server_remote_id_);
    }
  });
 }
@@ -1733,6 +1797,7 @@ void GuiApplication::Tick() {
    slint::quit_event_loop();
    return;
  }
+  HandleSessionCleanup();
  HandlePasswordChangeResult();
  HandleCredentialRecovery();
  if (!peer_) {
@@ -1789,6 +1854,7 @@ void GuiApplication::Tick() {
  HandleConnectionStatusChange();
  HandlePendingPresenceProbe();
  HandlePresenceProbeTimeout();
+  HandlePrivacy();
  HandleWindowsServiceIntegration();
 #if defined(__linux__) && !defined(__APPLE__)
  SyncXWaylandWindowActivation();
@@ -1807,60 +1873,170 @@ void GuiApplication::Tick() {
 }

 void GuiApplication::ShareLocalCursorState() {
+  constexpr auto kCursorEchoSuppressionInterval = 300ms;
  constexpr auto kCursorStateHeartbeatInterval = 500ms;
+  constexpr auto kCursorPositionShareInterval = 16ms;
+  constexpr float kCursorPositionEpsilon = 0.00005f;

-  bool has_connected_controller = false;
+  std::vector<std::string> connected_controllers;
  {
    std::shared_lock lock(connection_status_mutex_);
-    has_connected_controller =
-        std::any_of(connection_status_.begin(), connection_status_.end(),
-                    [](const auto& entry) {
-                      return entry.second == ConnectionStatus::Connected;
-                    });
+    connected_controllers.reserve(connection_status_.size());
+    for (const auto& [remote_id, status] : connection_status_) {
+      if (status == ConnectionStatus::Connected) {
+        connected_controllers.push_back(remote_id);
+      }
+    }
  }
-  if (!is_server_mode_ || !peer_ || !has_connected_controller) {
-    has_shared_cursor_state_ = false;
-    last_cursor_state_share_time_ = {};
+  if (!is_server_mode_ || !peer_ || connected_controllers.empty()) {
+    cursor_delivery_states_.clear();
    return;
  }

  CursorState sampled{};
-  if (!cursor_state_provider_.Sample(&sampled)) {
-    return;
+  const bool sample_ok = cursor_state_provider_.Sample(
+      devices_.display_info_list(), selected_display_, &sampled);
+  if (!sample_ok) {
+    sampled.render_mode = CursorRenderMode::unknown;
+    if (sampled.hidden_reason == CursorHiddenReason::unspecified) {
+      sampled.hidden_reason = CursorHiddenReason::sampling_failed;
+    }
+  } else if (sampled.render_mode == CursorRenderMode::legacy) {
+    // Providers without platform-specific presentation metadata only need to
+    // sample visible/shape; normalize that common case once for every peer.
+    sampled.render_mode = sampled.visible ? CursorRenderMode::separate
+                                          : CursorRenderMode::hidden;
+    sampled.hidden_reason = sampled.visible ? CursorHiddenReason::unspecified
+                                            : CursorHiddenReason::system_hidden;
  }

  const auto now = std::chrono::steady_clock::now();
-  const bool changed =
-      !has_shared_cursor_state_ ||
-      sampled.visible != last_shared_cursor_state_.visible ||
-      sampled.shape != last_shared_cursor_state_.shape;
-  const bool heartbeat_due =
-      last_cursor_state_share_time_.time_since_epoch().count() == 0 ||
-      now - last_cursor_state_share_time_ >= kCursorStateHeartbeatInterval;
-  if (!changed && !heartbeat_due) {
-    return;
+
+  std::unordered_map<std::string, std::chrono::steady_clock::time_point>
+      last_input_times;
+  {
+    std::lock_guard lock(remote_pointer_input_mutex_);
+    for (const auto& remote_id : connected_controllers) {
+      const auto input_it = last_remote_pointer_input_time_.find(remote_id);
+      if (input_it != last_remote_pointer_input_time_.end()) {
+        last_input_times.emplace(remote_id, input_it->second);
+      }
+    }
  }

+  std::unordered_set<std::string> connected_ids(connected_controllers.begin(),
+                                                connected_controllers.end());
+  std::erase_if(cursor_delivery_states_, [&](const auto& entry) {
+    return connected_ids.find(entry.first) == connected_ids.end();
+  });
+
+  struct CursorRecipient {
+    std::string remote_id;
+    bool include_position = true;
+  };
+  std::vector<CursorRecipient> recipients;
+  for (const auto& remote_id : connected_controllers) {
+    auto& delivery = cursor_delivery_states_[remote_id];
+    const auto input_it = last_input_times.find(remote_id);
+    const bool suppress_position =
+        input_it != last_input_times.end() &&
+        now - input_it->second < kCursorEchoSuppressionInterval;
+    delivery.feedback_pending =
+        delivery.feedback_pending || suppress_position;
+
+    const CursorState& previous = delivery.last_sent;
+    const bool shape_changed =
+        !delivery.has_sent || sampled.render_mode != previous.render_mode ||
+        sampled.hidden_reason != previous.hidden_reason ||
+        (sample_ok &&
+         (sampled.visible != previous.visible || sampled.shape != previous.shape ||
+          std::abs(sampled.visual_offset_x - previous.visual_offset_x) >
+              kCursorPositionEpsilon ||
+          std::abs(sampled.visual_offset_y - previous.visual_offset_y) >
+              kCursorPositionEpsilon));
+    // Preserve sub-point cursor motion. At 10x client zoom, the old roughly
+    // one-logical-pixel threshold became several visible phone points.
+    const bool position_changed =
+        sample_ok &&
+        (!delivery.has_sent || sampled.position_valid != previous.position_valid ||
+         sampled.display_id != previous.display_id ||
+         (sampled.position_valid && previous.position_valid &&
+          (std::abs(sampled.x - previous.x) > kCursorPositionEpsilon ||
+           std::abs(sampled.y - previous.y) > kCursorPositionEpsilon)));
+    const bool position_update_due =
+        position_changed &&
+        (delivery.last_sent_time.time_since_epoch().count() == 0 ||
+         now - delivery.last_sent_time >= kCursorPositionShareInterval);
+    const bool heartbeat_due =
+        delivery.last_sent_time.time_since_epoch().count() == 0 ||
+        now - delivery.last_sent_time >= kCursorStateHeartbeatInterval;
+    // Position feedback waits for a good sample and the echo-suppression
+    // interval. Appearance changes and heartbeats are independent of both.
+    const bool include_position = sample_ok && !suppress_position;
+    if (shape_changed || heartbeat_due ||
+        (include_position && (delivery.feedback_pending || position_update_due))) {
+      recipients.push_back({remote_id, include_position});
+    }
+  }
+  if (recipients.empty()) return;
+
  sampled.seq = ++cursor_state_sequence_;
-  RemoteAction action{};
-  action.type = ControlType::cursor_state;
-  action.cs = sampled;
-  const std::string message = action.to_json();
-  const int result = SendDataFrame(peer_, message.c_str(), message.size(),
-                                   mouse_label_.c_str());
-  if (result != 0) {
-    LOG_WARN("Send cursor state failed, ret={}", result);
-    return;
-  }
+  for (const auto& recipient : recipients) {
+    auto& delivery = cursor_delivery_states_[recipient.remote_id];
+    CursorState outgoing = sampled;
+    if (!sample_ok) {
+      // Explicitly report unknown to new receivers, but retain the last
+      // presentation for peers that only understand visible/shape.
+      outgoing = delivery.has_sent ? delivery.last_sent : CursorState{};
+      if (!delivery.has_sent) {
+        outgoing.visible = true;
+        outgoing.shape = RemoteCursorShape::default_cursor;
+      }
+      outgoing.seq = sampled.seq;
+      outgoing.render_mode = sampled.render_mode;
+      outgoing.hidden_reason = sampled.hidden_reason;
+    }
+    outgoing.position_update = recipient.include_position;
+    if (!recipient.include_position) {
+      // Keep legacy receivers at their last acknowledged position as well.
+      // New receivers honor position_update=false and leave their optimistic
+      // local position untouched.
+      outgoing.position_valid =
+          delivery.has_sent && delivery.last_sent.position_valid;
+      outgoing.x = delivery.has_sent ? delivery.last_sent.x : 0.5f;
+      outgoing.y = delivery.has_sent ? delivery.last_sent.y : 0.5f;
+      outgoing.display_id = delivery.has_sent
+                                ? delivery.last_sent.display_id
+                                : -1;
+    }

-  if (changed) {
-    LOG_INFO("Sent cursor state: seq={}, visible={}, shape={}", sampled.seq,
-             sampled.visible, static_cast<int>(sampled.shape));
-  }
+    RemoteAction action{};
+    action.type = ControlType::cursor_state;
+    action.cs = outgoing;
+    const std::string message = action.to_json();
+    const int result = SendReliableDataFrameToPeer(
+        peer_, message.c_str(), message.size(), mouse_label_.c_str(),
+        recipient.remote_id.c_str(), recipient.remote_id.size());
+    if (result != 0) {
+      LOG_WARN("Send cursor state to [{}] failed, ret={}",
+               recipient.remote_id, result);
+      continue;
+    }

-  last_shared_cursor_state_ = sampled;
-  has_shared_cursor_state_ = true;
-  last_cursor_state_share_time_ = now;
+    if (!delivery.has_sent ||
+        delivery.last_sent.render_mode != outgoing.render_mode ||
+        delivery.last_sent.hidden_reason != outgoing.hidden_reason) {
+      LOG_INFO("Send cursor presentation to [{}]: mode={}, reason={}",
+               recipient.remote_id, static_cast<int>(outgoing.render_mode),
+               static_cast<int>(outgoing.hidden_reason));
+    }
+    delivery.last_sent = outgoing;
+    delivery.has_sent = true;
+    if (recipient.include_position) {
+      delivery.feedback_pending = false;
+    }
+    delivery.last_sent_time = now;
+  }
 }

 void GuiApplication::HandlePasswordChangeResult() {
@@ -1911,8 +2087,7 @@ void GuiApplication::HandlePasswordChangeResult() {
    }
    show_offline_warning_window_ = true;
    if (uncertain && peer_) {
-      LeaveConnection(peer_, client_id_);
-      DestroyPeer(&peer_);
+      CloseConnectionPeer();
    }
    return;
  }
@@ -1925,8 +2100,7 @@ void GuiApplication::HandlePasswordChangeResult() {

  LOG_INFO("Password changed successfully for [{}]", client_id_);
  if (peer_) {
-    LeaveConnection(peer_, client_id_);
-    DestroyPeer(&peer_);
+    CloseConnectionPeer();
  }
 }

@@ -1950,7 +2124,7 @@ void GuiApplication::HandleCredentialRecovery() {
  if (retry_active) {
    LOG_INFO("Pending credential was not accepted; retrying active credential");
    if (peer_) {
-      DestroyPeer(&peer_);
+      CloseConnectionPeer();
    }
    return;
  }
@@ -1995,6 +2169,9 @@ void GuiApplication::SyncMainWindow() {
  if (!ui_) {
    return;
  }
+#if _WIN32
+  ConfigureWindowsWindowIcons(ui_->main->window().win32_hwnd());
+#endif
 #if defined(__APPLE__)
  if (ui_->main_native_titlebar_attempts > 0) {
    if (HideDisabledMainWindowZoomButton()) {
@@ -2019,15 +2196,7 @@ void GuiApplication::SyncMainWindow() {
  ui_->main->set_latest_version(UiText(latest_version_));
  ui_->main->set_release_name(UiText(release_name_));
  ui_->main->set_release_date(UiText(release_date_));
-  ui_->main->set_settings_session_active(stream_window_inited_);
-#if (((defined(_WIN32) || defined(__linux__)) && !defined(__aarch64__) && \
-      !defined(__arm__) && USE_CUDA) ||                                   \
-     defined(__APPLE__))
-  ui_->main->set_hardware_codec_available(true);
-#else
-  ui_->main->set_hardware_codec_available(false);
-#endif
-
+  ui_->main->set_settings_session_active(HasActiveSession());
  if (show_offline_warning_window_) {
    ui_->main->set_offline_warning(UiText(offline_warning_text_));
    show_offline_warning_window_ = false;
@@ -2237,6 +2406,7 @@ void GuiApplication::SetStreamKeyboardFocus(bool focused) {

  focus_on_stream_window_ = focused;
  if (!focused) {
+    devices_.StopKeyboardCapturer();
    keyboard_.ForceReleasePressedKeys();
  }
 }
@@ -2291,8 +2461,10 @@ void GuiApplication::SyncStreamWindow() {
  if (!ui_->stream) {
    return;
  }
+#if _WIN32
+  ConfigureWindowsWindowIcons((*ui_->stream)->window().win32_hwnd());
+#endif
  (*ui_->stream)->set_window_maximized((*ui_->stream)->window().is_maximized());
-  (*ui_->stream)->set_srtp_enabled(enable_srtp_);
 #if defined(__APPLE__)
  if (ui_->stream_live_resize_configuration_attempts > 0) {
    if (ConfigureStreamWindowLiveResize(
@@ -2422,6 +2594,29 @@ void GuiApplication::SyncStreamWindow() {
              ? localization::receiving_screen[localization_language_index_]
              : std::string{}));
  (*ui_->stream)->set_mouse_control_enabled(props->control_mouse_);
+  {
+    std::lock_guard lock(props->privacy_status_mutex_);
+    const auto& status = props->privacy_status_;
+    const uint64_t now = SDL_GetTicks();
+    const auto controls = GetPrivacyControlState(
+        status, props->privacy_status_received_, props->privacy_command_pending_,
+        now - props->privacy_status_tick_, now - props->privacy_command_tick_);
+    const bool connected =
+        props->connection_status_.load() == ConnectionStatus::Connected;
+    (*ui_->stream)->set_privacy_active(controls.active);
+    (*ui_->stream)->set_privacy_off(connected && controls.off);
+    (*ui_->stream)->set_privacy_unsupported(controls.unsupported);
+    (*ui_->stream)->set_privacy_can_toggle(
+        props->control_mouse_ && connected && controls.can_toggle);
+    const int language = localization_language_index_;
+    std::string text = !connected || !props->privacy_status_received_
+        ? localization::privacy_screen[language]
+        : controls.unsupported ? localization::privacy_unsupported[language]
+        : controls.enabled ? localization::privacy_on[language]
+        : controls.off ? localization::privacy_off[language]
+        : localization::privacy_screen[language];
+    (*ui_->stream)->set_privacy_status_text(UiText(text));
+  }
  int remote_cursor_shape =
      static_cast<int>(RemoteCursorShape::default_cursor);
  bool remote_cursor_active = false;
@@ -2432,9 +2627,7 @@ void GuiApplication::SyncStreamWindow() {
        props->remote_cursor_state_received_;
    if (remote_cursor_active) {
      remote_cursor_shape = static_cast<int>(
-          props->remote_cursor_state_.visible
-              ? props->remote_cursor_state_.shape
-              : RemoteCursorShape::none);
+          props->cursor_presentation_.Resolve(SDL_GetTicks()));
    }
  }
  (*ui_->stream)->set_remote_cursor_active(remote_cursor_active);
@@ -2459,6 +2652,8 @@ void GuiApplication::SyncStreamWindow() {
  (*ui_->stream)->set_selected_display(props->selected_display_);

  const auto& net = props->net_traffic_stats_;
+  (*ui_->stream)->set_stats_encryption_enabled(
+      status == ConnectionStatus::Connected && net.srtp_active);
  std::vector<ui::NetworkStatsRow> stats_rows;
  stats_rows.reserve(4);
  const auto append_stats_row = [&](const std::string& label,
@@ -2665,7 +2860,19 @@ void GuiApplication::SyncServerWindow() {
                    });
  }

-  if (has_connected_controller && !ui_->server) {
+  // Privacy protects local display output while preserving capture.
+  // Keep the panel alive throughout privacy transitions so remote
+  // controllers can still see and operate it without resetting its UI state.
+  bool show_controller_window = has_connected_controller;
+#if !defined(_WIN32) && !defined(__APPLE__) && !defined(__linux__)
+  // Preserve the existing panel behavior on other platforms.
+  const auto privacy_status = privacy_.Snapshot();
+  const bool privacy_covering = privacy_status.overlay_active ||
+      privacy_status.state == PrivacyState::starting ||
+      privacy_status.state == PrivacyState::stopping;
+  show_controller_window = show_controller_window && !privacy_covering;
+#endif
+  if (show_controller_window && !ui_->server) {
    ui_->server.emplace(ui::ServerWindow::create());
    RegisterFontAwesome((*ui_->server)->window());
    (*ui_->server)->set_controllers(ui_->controller_model);
@@ -2689,7 +2896,7 @@ void GuiApplication::SyncServerWindow() {
    server_window_created_ = true;
    server_window_inited_ = true;
  }
-  if (!has_connected_controller && ui_->server) {
+  if (!show_controller_window && ui_->server) {
    (*ui_->server)->hide();
    ui_->server.reset();
    server_window_created_ = false;
@@ -2703,6 +2910,10 @@ void GuiApplication::SyncServerWindow() {
    return;
  }

+#if _WIN32
+  ConfigureWindowsWindowIcons((*ui_->server)->window().win32_hwnd());
+#endif
+
  std::vector<ui::ControllerEntry> controllers;
  std::vector<slint::SharedString> names;
  ui_->controller_ids.clear();
@@ -2819,10 +3030,12 @@ void GuiApplication::SaveSettingsFromUi() {
      std::clamp(main->get_video_quality_index(), 0, 2);
  video_frame_rate_button_value_ =
      std::clamp(main->get_frame_rate_index(), 0, 1);
+  video_adaptation_policy_button_value_ =
+      std::clamp(main->get_adaptation_policy_index(), 0, 2);
  video_encode_format_button_value_ = std::clamp(main->get_codec_index(), 0, 1);
-  enable_hardware_video_codec_ = main->get_hardware_codec_enabled();
+  enable_hardware_video_codec_ = ConfigCenter::IsHardwareVideoCodecAvailable() &&
+                                  main->get_hardware_codec_enabled();
  enable_turn_ = main->get_turn_enabled();
-  enable_srtp_ = main->get_srtp_enabled();
  enable_self_hosted_ = main->get_self_hosted_enabled();
  enable_autostart_ = main->get_autostart_enabled();
  enable_daemon_ = main->get_daemon_enabled();
@@ -2831,19 +3044,41 @@ void GuiApplication::SaveSettingsFromUi() {
      static_cast<ConfigCenter::LANGUAGE>(language_button_value_);
  localization_language_index_ = language_button_value_;
  config_center_->SetLanguage(localization_language_);
+  privacy_.SetText({
+      localization::privacy_screen_unlock_hint[localization_language_index_]});
  config_center_->SetVideoQuality(
      static_cast<ConfigCenter::VIDEO_QUALITY>(video_quality_button_value_));
  config_center_->SetVideoFrameRate(static_cast<ConfigCenter::VIDEO_FRAME_RATE>(
      video_frame_rate_button_value_));
+  config_center_->SetVideoAdaptationPolicy(
+      static_cast<ConfigCenter::VIDEO_ADAPTATION_POLICY>(
+          video_adaptation_policy_button_value_));
  config_center_->SetVideoEncodeFormat(
      static_cast<ConfigCenter::VIDEO_ENCODE_FORMAT>(
          video_encode_format_button_value_));
  config_center_->SetHardwareVideoCodec(enable_hardware_video_codec_);
  config_center_->SetTurn(enable_turn_);
-  config_center_->SetSrtp(enable_srtp_);
  config_center_->SetSelfHosted(enable_self_hosted_);
  config_center_->SetAutostart(enable_autostart_);
  config_center_->SetDaemon(enable_daemon_);
+#ifdef _WIN32
+  if (!HasActiveSession()) {
+    const auto capture_method = static_cast<ScreenCaptureMethod>(
+        std::clamp(main->get_capture_method_index(), 0, 3));
+    if (config_center_->SetScreenCaptureMethod(capture_method) != 0) {
+      LOG_ERROR("Failed to save screen capture method");
+    }
+  }
+  main->set_capture_method_index(
+      static_cast<int>(config_center_->GetScreenCaptureMethod()));
+#endif
+#if defined(_WIN32) || defined(__APPLE__) || defined(__linux__)
+  if (config_center_->SetPrivacyScreen(main->get_privacy_on_connect_enabled()) !=
+      0) {
+    main->set_privacy_on_connect_enabled(
+        config_center_->IsEnablePrivacyScreen());
+  }
+#endif

  const std::string path(main->get_file_save_path());
  std::memset(file_transfer_save_path_buf_, 0,
@@ -2859,24 +3094,22 @@ void GuiApplication::SaveSettingsFromUi() {
  if (const auto port = ParsePort(main->get_server_port())) {
    config_center_->SetServerPort(*port);
  }
-  if (const auto port = ParsePort(main->get_coturn_port())) {
-    config_center_->SetCoturnServerPort(*port);
-  }

  language_button_value_last_ = language_button_value_;
  video_quality_button_value_last_ = video_quality_button_value_;
  video_frame_rate_button_value_last_ = video_frame_rate_button_value_;
+  video_adaptation_policy_button_value_last_ =
+      video_adaptation_policy_button_value_;
  video_encode_format_button_value_last_ = video_encode_format_button_value_;
  enable_hardware_video_codec_last_ = enable_hardware_video_codec_;
  enable_turn_last_ = enable_turn_;
-  enable_srtp_last_ = enable_srtp_;
  enable_self_hosted_last_ = enable_self_hosted_;
  enable_autostart_last_ = enable_autostart_;
  enable_daemon_last_ = enable_daemon_;
  file_transfer_save_path_last_ = path;
  ui_->localized_language = -1;

-  if (!stream_window_inited_) {
+  if (!HasActiveSession()) {
    CloseAllRemoteSessions();
    CreateConnectionPeer();
  }
@@ -2913,6 +3146,7 @@ void GuiApplication::SelectStreamTab(int index) {
  bool renderer_selection_changed = false;
  if (!controlled_remote_id_.empty() &&
      controlled_remote_id_ != selected_remote_id) {
+    devices_.StopKeyboardCapturer();
    keyboard_.ForceReleasePressedKeys();
  }
  focused_remote_id_ = selected_remote_id;
@@ -2979,9 +3213,6 @@ void GuiApplication::CloseStreamTab(const std::string& remote_id) {
  }
  keyboard_.ReleaseRemotePressedKeys(remote_id, "stream_tab_closed");
  CloseRemoteSession(props);
-  WaitForThumbnailSaveTasks();
-  reload_recent_connections_ = true;
-  recent_connection_image_save_time_ = 0;
  ResetRemoteSessionResources(props);
  {
    std::unique_lock lock(remote_sessions_mutex_);
@@ -3085,8 +3316,12 @@ void GuiApplication::SendPointerInput(int button, int kind, float x, float y) {

  controlled_remote_id_ = props->remote_id_;
  const std::string message = action.to_json();
-  SendDataFrame(props->peer_, message.c_str(), message.size(),
-                props->mouse_label_.c_str());
+  {
+    std::lock_guard lock(props->remote_cursor_state_mutex_);
+    props->cursor_presentation_.NoteInput(SDL_GetTicks());
+  }
+  SendReliableDataFrame(props->peer_, message.c_str(), message.size(),
+                        props->mouse_label_.c_str());
 }

 void GuiApplication::SendScrollInput(float delta_x, float delta_y, float x,
@@ -3123,10 +3358,14 @@ void GuiApplication::SendScrollInput(float delta_x, float delta_y, float x,
  if (action.m.s == 0) {
    return;
  }
+  {
+    std::lock_guard lock(props->remote_cursor_state_mutex_);
+    props->cursor_presentation_.NoteInput(SDL_GetTicks());
+  }
  controlled_remote_id_ = props->remote_id_;
  const std::string message = action.to_json();
-  SendDataFrame(props->peer_, message.c_str(), message.size(),
-                props->mouse_label_.c_str());
+  SendReliableDataFrame(props->peer_, message.c_str(), message.size(),
+                        props->mouse_label_.c_str());
 }

 void GuiApplication::SendKeyInput(const std::string& text, bool pressed,
@@ -3181,12 +3420,15 @@ void GuiApplication::Cleanup() {
 #if _WIN32 && CROSSDESK_PORTABLE
  JoinPortableWindowsServiceInstallThread();
 #endif
+  privacy_.Disable();
  clipboard_.Shutdown();
  keyboard_.ForceReleasePressedKeys();
+  keyboard_.ReleaseAllRemotePressedKeys("application_exit");
  devices_.DestroyDevices();
+  privacy_.Shutdown();
  devices_.DestroyFactories();
  CloseAllRemoteSessions();
-  WaitForThumbnailSaveTasks();
+  WaitForSessionCleanup();
  devices_.DestroyAudioOutput();
  if (ui_->stream) {
 #if defined(__APPLE__)
@@ -1,9 +1,18 @@
-#ifndef CROSSDESK_GUI_APPLICATION_H_
-#define CROSSDESK_GUI_APPLICATION_H_
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-04
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _GUI_APPLICATION_H_
+#define _GUI_APPLICATION_H_

 #include <chrono>
 #include <memory>
 #include <string>
+#include <unordered_map>
+
+#include <remote_action.h>

 #include "runtime/cursor_state_provider.h"
 #include "runtime/gui_runtime.h"
@@ -21,6 +30,12 @@ public:

 private:
  struct SlintUi;
+  struct CursorDeliveryState {
+    CursorState last_sent{};
+    bool has_sent = false;
+    bool feedback_pending = false;
+    std::chrono::steady_clock::time_point last_sent_time{};
+  };

  void InitializeLogger();
  void InitializeSettings();
@@ -73,10 +88,9 @@ private:

  std::unique_ptr<SlintUi> ui_;
  CursorStateProvider cursor_state_provider_;
-  CursorState last_shared_cursor_state_{};
-  bool has_shared_cursor_state_ = false;
+  std::unordered_map<std::string, CursorDeliveryState>
+      cursor_delivery_states_;
  uint32_t cursor_state_sequence_ = 0;
-  std::chrono::steady_clock::time_point last_cursor_state_share_time_{};
  std::chrono::steady_clock::time_point next_video_frame_time_{};
 #if defined(__linux__) && !defined(__APPLE__)
  bool use_xwayland_gui_ = false;
@@ -86,4 +100,4 @@ private:

 } // namespace crossdesk

-#endif // CROSSDESK_GUI_APPLICATION_H_
+#endif
@@ -1,5 +1,7 @@
 #include "application/gui_application.h"

+#include <remote_action.h>
+
 #include <algorithm>
 #include <cmath>
 #include <string>
@@ -233,6 +235,15 @@ int GuiApplication::ProcessKeyboardEvent(const SDL_Event &event) {
 int GuiApplication::ProcessMouseEvent(const SDL_Event &event) {
  controlled_remote_id_ = "";
  RemoteAction remote_action{};
+
+  if ((event.type == SDL_EVENT_MOUSE_BUTTON_DOWN ||
+       event.type == SDL_EVENT_MOUSE_BUTTON_UP) &&
+      event.button.button != SDL_BUTTON_LEFT &&
+      event.button.button != SDL_BUTTON_RIGHT &&
+      event.button.button != SDL_BUTTON_MIDDLE) {
+    return 0;
+  }
+
  float cursor_x = last_mouse_event.motion.x;
  float cursor_y = last_mouse_event.motion.y;

@@ -355,8 +366,8 @@ int GuiApplication::ProcessMouseEvent(const SDL_Event &event) {
      }
      if (props->peer_) {
        std::string msg = remote_action.to_json();
-        SendDataFrame(props->peer_, msg.c_str(), msg.size(),
-                      props->mouse_label_.c_str());
+        SendReliableDataFrame(props->peer_, msg.c_str(), msg.size(),
+                              props->mouse_label_.c_str());
      }
    } else if (SDL_EVENT_MOUSE_WHEEL == event.type &&
               last_mouse_event.button.x >= render_rect.x &&
@@ -401,8 +412,8 @@ int GuiApplication::ProcessMouseEvent(const SDL_Event &event) {
      }
      if (props->peer_) {
        std::string msg = remote_action.to_json();
-        SendDataFrame(props->peer_, msg.c_str(), msg.size(),
-                      props->mouse_label_.c_str());
+        SendReliableDataFrame(props->peer_, msg.c_str(), msg.size(),
+                              props->mouse_label_.c_str());
      }
    }
  }
@@ -1,4 +1,11 @@
-#pragma once
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-04
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _SERVER_WINDOW_STATE_H_
+#define _SERVER_WINDOW_STATE_H_

 #include <algorithm>
 #include <iterator>
@@ -24,5 +31,6 @@ inline int ReconcileSelectedController(const std::vector<std::string>& ids,
  }
  return static_cast<int>(std::distance(ids.begin(), selected));
 }
+} // namespace crossdesk::server_window_state

-}  // namespace crossdesk::server_window_state
+#endif
@@ -1,4 +1,11 @@
-#pragma once
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-04
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _WINDOW_GEOMETRY_H_
+#define _WINDOW_GEOMETRY_H_

 #include <algorithm>

@@ -38,3 +45,5 @@ constexpr PhysicalPosition BottomRightPosition(const PhysicalRect& bounds,
 }

 }  // namespace crossdesk::window_geometry
+
+#endif
@@ -53,8 +53,6 @@
 #define ENABLE_HARDWARE_VIDEO_CODEC_CHECKBOX_PADDING_EN 218 * dpi_scale_
 #define ENABLE_TURN_CHECKBOX_PADDING_CN 171 * dpi_scale_
 #define ENABLE_TURN_CHECKBOX_PADDING_EN 218 * dpi_scale_
-#define ENABLE_SRTP_CHECKBOX_PADDING_CN 171 * dpi_scale_
-#define ENABLE_SRTP_CHECKBOX_PADDING_EN 218 * dpi_scale_
 #define ENABLE_SELF_HOSTED_SERVER_CHECKBOX_PADDING_CN 171 * dpi_scale_
 #define ENABLE_SELF_HOSTED_SERVER_CHECKBOX_PADDING_EN 218 * dpi_scale_
 #define ENABLE_AUTOSTART_PADDING_CN 171 * dpi_scale_
@@ -57,8 +57,6 @@
 #define ENABLE_HARDWARE_VIDEO_CODEC_CHECKBOX_PADDING_EN 218
 #define ENABLE_TURN_CHECKBOX_PADDING_CN 171
 #define ENABLE_TURN_CHECKBOX_PADDING_EN 218
-#define ENABLE_SRTP_CHECKBOX_PADDING_CN 171
-#define ENABLE_SRTP_CHECKBOX_PADDING_EN 218
 #define ENABLE_SELF_HOSTED_SERVER_CHECKBOX_PADDING_CN 171
 #define ENABLE_SELF_HOSTED_SERVER_CHECKBOX_PADDING_EN 218
 #define ENABLE_AUTOSTART_PADDING_CN 171
@@ -20,6 +20,12 @@ struct TranslationRow {

 // Single source of truth for all UI strings.
 #define CROSSDESK_LOCALIZATION_ALL(X)                                          \
+  X(privacy_screen, u8"隐私屏", "Privacy screen", u8"Приватный экран") \
+  X(privacy_enable, u8"开启隐私屏", "Enable privacy screen", u8"Включить приватный экран") \
+  X(privacy_disable, u8"关闭隐私屏", "Disable privacy screen", u8"Выключить приватный экран") \
+  X(privacy_on, u8"隐私屏：已开启", "Privacy screen: on", u8"Приватный экран: включён") \
+  X(privacy_off, u8"隐私屏：已关闭", "Privacy screen: off", u8"Приватный экран: выключен") \
+  X(privacy_unsupported, u8"隐私屏：不可用", "Privacy screen: unavailable", u8"Приватный экран: недоступен") \
  X(local_desktop, u8"本桌面", "Local Desktop", u8"Локальный рабочий стол")    \
  X(local_id, u8"本机ID", "Local ID", u8"Локальный ID")                        \
  X(local_id_copied_to_clipboard, u8"已复制到剪贴板", "Copied to clipboard",   \
@@ -120,9 +126,18 @@ struct TranslationRow {
    u8"стола")                                                                 \
  X(settings, u8"设置", "Settings", u8"Настройки")                             \
  X(language, u8"语言:", "Language:", u8"Язык:")                               \
-  X(video_quality, u8"视频质量:", "Video Quality:", u8"Качество видео:")       \
+  X(screen_capture_method, u8"采集方式:", "Capture Method:",                  \
+    u8"Способ захвата:")                                                      \
+  X(screen_capture_method_auto, u8"自动", "Auto", u8"Авто")                 \
+  X(video_quality, u8"画面质量:", "Video Quality:", u8"Качество видео:")       \
  X(video_frame_rate, u8"画面采集帧率:",                                       \
    "Video Capture Frame Rate:", u8"Частота захвата видео:")                   \
+  X(video_adaptation_policy, u8"画面偏好:", "Video Preference:",              \
+    u8"Режим видео:")                                                           \
+  X(video_priority_frame_rate, u8"帧率优先", "Frame Rate",                   \
+    u8"Частота кадров")                                                         \
+  X(video_priority_quality, u8"画质优先", "Quality", u8"Качество")          \
+  X(video_priority_balanced, u8"平衡", "Balanced", u8"Баланс")              \
  X(video_quality_high, u8"高", "High", u8"Высокое")                           \
  X(video_quality_medium, u8"中", "Medium", u8"Среднее")                       \
  X(video_quality_low, u8"低", "Low", u8"Низкое")                              \
@@ -134,7 +149,6 @@ struct TranslationRow {
    "Enable Hardware Video Codec:", u8"Использовать аппаратный кодек:")        \
  X(enable_turn, u8"启用中继服务:",                                            \
    "Enable TURN Service:", u8"Включить TURN-сервис:")                         \
-  X(enable_srtp, u8"启用SRTP:", "Enable SRTP:", u8"Включить SRTP:")            \
  X(self_hosted_server_config, u8"自托管配置", "Self-Hosted Config",           \
    u8"Конфигурация self-hosted")                                              \
  X(self_hosted_server_settings, u8"自托管设置", "Self-Hosted Settings",       \
@@ -143,8 +157,6 @@ struct TranslationRow {
    "Server Address:", u8"Адрес сервера:")                                     \
  X(self_hosted_server_port, u8"信令服务端口:",                                \
    "Signal Service Port:", u8"Порт сигнального сервиса:")                     \
-  X(self_hosted_server_coturn_server_port, u8"中继服务端口:",                  \
-    "Relay Service Port:", u8"Порт реле-сервиса:")                             \
  X(ok, u8"确认", "OK", u8"ОК")                                                \
  X(cancel, u8"取消", "Cancel", u8"Отмена")                                    \
  X(new_password, u8"请输入六位密码:",                                         \
@@ -198,6 +210,8 @@ struct TranslationRow {
    "Confirm to delete this connection", u8"Удалить это подключение?")         \
  X(enable_autostart, u8"开机自启:", "Auto Start:", u8"Автозапуск:")           \
  X(enable_daemon, u8"启用守护进程:", "Enable Daemon:", u8"Включить демон:")   \
+  X(privacy_on_connect, u8"被连接时开启隐私屏:", "Privacy screen on connect:", \
+    u8"Приватность при подключении:")                                       \
  X(takes_effect_after_restart, u8"重启后生效", "Takes effect after restart",  \
    u8"Вступит в силу после перезапуска")                                      \
  X(select_file, u8"选择文件发送", "Select File to Send",                      \
@@ -219,6 +233,9 @@ struct TranslationRow {
  X(connection_mode, u8"连接模式", "Mode", u8"Режим")                          \
  X(connection_mode_direct, u8"直连", "Direct", u8"Прямой")                    \
  X(connection_mode_relay, u8"中继", "Relay", u8"Релейный")                    \
+  X(transport_encryption, u8"加密传输", "Encryption", u8"Шифрование")         \
+  X(transport_encryption_enabled, u8"已开启", "Enabled", u8"Включено")         \
+  X(transport_encryption_disabled, u8"未开启", "Disabled", u8"Выключено")       \
  X(online, u8"在线", "Online", u8"Онлайн")                                    \
  X(offline, u8"离线", "Offline", u8"Офлайн")                                  \
  X(device_offline, u8"设备离线", "Device Offline", u8"Устройство офлайн")     \
@@ -233,6 +250,9 @@ struct TranslationRow {
    u8"Для работы приложения требуются следующие разрешения:")                 \
  X(show_main_window, u8"显示主界面", "Show Main Window",                    \
    u8"Показать главное окно")                                                \
+  X(privacy_screen_unlock_hint, u8"按下快捷键，解除隐私屏",                    \
+    "To turn off the privacy screen, press",                                 \
+    u8"Чтобы отключить приватный экран, нажмите")                             \
  X(exit_program, u8"退出", "Exit", u8"Выход")

 inline constexpr TranslationRow kTranslationRows[] = {
@@ -1,12 +1,20 @@
 #include "features/devices/session_device_manager.h"

+#include <display_stream_id.h>
+#include <remote_action.h>
+
+#include <algorithm>
 #include <chrono>
 #include <cstdlib>

-#include "display_stream_id.h"
 #include "platform.h"
 #include "rd_log.h"
 #include "runtime/gui_runtime.h"
+#include "speaker_capturer_factory.h"
+#ifdef _WIN32
+#include "platform/windows/screen_capturer/screen_capturer_win.h"
+#include "platform/windows/input/mouse/mouse_controller.h"
+#endif

 namespace crossdesk {
 namespace {
@@ -17,7 +25,23 @@ constexpr auto kFrameDeadlineTolerance = std::chrono::milliseconds(1);

 } // namespace

-SessionDeviceManager::SessionDeviceManager(GuiRuntime &owner) : owner_(owner) {}
+SessionDeviceManager::SessionDeviceManager(GuiRuntime &owner)
+    : owner_(owner),
+      speaker_capture_(
+          [] {
+            return std::unique_ptr<SpeakerCapturer>(
+                SpeakerCapturerFactory().Create());
+          },
+          [this](unsigned char *data, size_t size, const char *) {
+            if (!owner_.peer_) return;
+            MiniRtcAudioFrame frame{};
+            frame.data = reinterpret_cast<const char *>(data);
+            frame.size = size;
+            frame.captured_timestamp = GetSystemTimeMicros(owner_.peer_);
+            SendAudioFrame(owner_.peer_, &frame, owner_.audio_label_.c_str());
+          }) {}
+
+SessionDeviceManager::~SessionDeviceManager() { speaker_capture_.Shutdown(); }

 bool SessionDeviceManager::ShouldSendCapturedFrame(
    std::chrono::steady_clock::time_point now, int fps) {
@@ -36,10 +60,56 @@ bool SessionDeviceManager::ShouldSendCapturedFrame(
  return true;
 }

+void SessionDeviceManager::RecordCaptureCadence(
+    std::chrono::steady_clock::time_point now, int fps,
+    bool from_secure_desktop) {
+  std::lock_guard<std::mutex> lock(capture_metrics_mutex_);
+  if (capture_metrics_started_ == std::chrono::steady_clock::time_point{})
+    capture_metrics_started_ = now;
+  const auto elapsed_us = std::chrono::duration_cast<std::chrono::microseconds>(
+                              now - capture_metrics_started_)
+                              .count();
+  if (elapsed_us >= 2000000) {
+    if (capture_forwarded_) {
+      const char* source = capture_secure_callbacks_ == 0 ? "normal_desktop"
+                           : capture_secure_callbacks_ == capture_callbacks_
+                               ? "secure_desktop"
+                               : "mixed";
+      LOG_INFO(
+          "Capture delivery: source={} normal_callbacks={} secure_callbacks={} "
+          "target_fps={} input_fps={:.2f} "
+          "forwarded_fps={:.2f} callbacks={} rate_dropped={} "
+          "forwarded={} send_errors={} max_callback_gap_us={} "
+          "send_avg_us={} send_max_us={} window_ms={}",
+          source, capture_callbacks_ - capture_secure_callbacks_,
+          capture_secure_callbacks_, fps,
+          capture_callbacks_ * 1000000.0 / elapsed_us,
+          capture_forwarded_ * 1000000.0 / elapsed_us, capture_callbacks_,
+          capture_rate_drops_, capture_forwarded_, capture_send_errors_,
+          capture_max_gap_us_, capture_send_us_ / capture_forwarded_,
+          capture_max_send_us_, elapsed_us / 1000);
+    }
+    capture_metrics_started_ = now;
+    capture_callbacks_ = capture_rate_drops_ = capture_forwarded_ = 0;
+    capture_secure_callbacks_ = 0;
+    capture_send_errors_ = 0;
+    capture_max_gap_us_ = capture_send_us_ = capture_max_send_us_ = 0;
+  }
+  if (last_capture_callback_ != std::chrono::steady_clock::time_point{}) {
+    capture_max_gap_us_ =
+        std::max<int64_t>(capture_max_gap_us_,
+                          std::chrono::duration_cast<std::chrono::microseconds>(
+                              now - last_capture_callback_)
+                              .count());
+  }
+  last_capture_callback_ = std::max(last_capture_callback_, now);
+  ++capture_callbacks_;
+  if (from_secure_desktop) ++capture_secure_callbacks_;
+}
+
 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(
@@ -57,9 +127,20 @@ int SessionDeviceManager::InitializeScreenCapturer() {
    screen_capturer_ =
        static_cast<ScreenCapturer *>(screen_capturer_factory_->Create());
  }
+  screen_capturer_->SetPrivacyController(&owner_.privacy_);
+#ifdef _WIN32
+  if (auto windows = dynamic_cast<ScreenCapturerWin*>(screen_capturer_)) {
+    windows->SetCaptureMethod(owner_.config_center_->GetScreenCaptureMethod());
+  }
+#endif

  last_frame_time_ = {};
  next_frame_deadline_ = {};
+  capture_metrics_started_ = last_capture_callback_ = {};
+  capture_callbacks_ = capture_rate_drops_ = capture_forwarded_ = 0;
+  capture_secure_callbacks_ = 0;
+  capture_send_errors_ = 0;
+  capture_max_gap_us_ = capture_send_us_ = capture_max_send_us_ = 0;
  const int fps = owner_.config_center_->GetVideoFrameRate() ==
                          ConfigCenter::VIDEO_FRAME_RATE::FPS_30
                      ? 30
@@ -72,9 +153,18 @@ int SessionDeviceManager::InitializeScreenCapturer() {

  const int init_ret = screen_capturer_->Init(
      fps, [this, fps](unsigned char *data, int size, int width, int height,
-                       const char *display_name) {
+                       const char *display_name,
+                       const MiniRtcNativeVideoFrame *native_frame) {
        const auto now_time = std::chrono::steady_clock::now();
+        bool from_secure_desktop = false;
+#ifdef _WIN32
+        from_secure_desktop =
+            ScreenCapturerWin::CurrentFrameIsFromSecureDesktop();
+#endif
+        RecordCaptureCadence(now_time, fps, from_secure_desktop);
        if (!ShouldSendCapturedFrame(now_time, fps)) {
+          std::lock_guard<std::mutex> lock(capture_metrics_mutex_);
+          ++capture_rate_drops_;
          return;
        }

@@ -134,15 +224,31 @@ int SessionDeviceManager::InitializeScreenCapturer() {
          }
        }

-        XVideoFrame frame{};
+        MiniRtcVideoFrame frame{};
        frame.data = reinterpret_cast<const char *>(data);
        frame.size = size;
        frame.width = width;
        frame.height = height;
        frame.captured_timestamp = GetSystemTimeMicros(owner_.peer_);
+        frame.native_frame = native_frame;
+        const auto send_started = std::chrono::steady_clock::now();
+        uint64_t send_errors = 0;
        for (const std::string &remote_id : connected_remote_ids) {
-          SendVideoFrameToPeer(owner_.peer_, &frame, stream_id.c_str(),
-                               remote_id.data(), remote_id.size());
+          if (SendVideoFrameToPeer(owner_.peer_, &frame, stream_id.c_str(),
+                                   remote_id.data(), remote_id.size()) != 0)
+            ++send_errors;
+        }
+        const auto send_us =
+            std::chrono::duration_cast<std::chrono::microseconds>(
+                std::chrono::steady_clock::now() - send_started)
+                .count();
+        {
+          std::lock_guard<std::mutex> lock(capture_metrics_mutex_);
+          ++capture_forwarded_;
+          capture_send_errors_ += send_errors;
+          capture_send_us_ += send_us;
+          capture_max_send_us_ =
+              std::max<int64_t>(capture_max_send_us_, send_us);
        }
        last_video_frame_stream_id_ = stream_id;
        last_frame_time_ = now_time;
@@ -165,6 +271,15 @@ int SessionDeviceManager::InitializeScreenCapturer() {
  return -1;
 }

+bool SessionDeviceManager::ShouldCaptureCursor() const {
+  std::shared_lock lock(owner_.connection_status_mutex_);
+  return std::any_of(owner_.connection_status_.begin(),
+                     owner_.connection_status_.end(), [](const auto& entry) {
+    return entry.second == ConnectionStatus::Connected &&
+           entry.first.find("web") != std::string::npos;
+  });
+}
+
 int SessionDeviceManager::StartScreenCapturer() {
 #ifdef __APPLE__
  if (!owner_.EnsureMacScreenRecordingPermission()) {
@@ -180,8 +295,11 @@ int SessionDeviceManager::StartScreenCapturer() {
    }
  }

-  LOG_INFO("Start screen capturer, show cursor: {}", owner_.show_cursor_);
-  const int ret = screen_capturer_->Start(owner_.show_cursor_);
+  // Clear before sampling, so a change arriving after the sample remains pending.
+  cursor_capture_dirty_.store(false, std::memory_order_relaxed);
+  const bool show_cursor = ShouldCaptureCursor();
+  LOG_INFO("Start screen capturer, show cursor: {}", show_cursor);
+  const int ret = screen_capturer_->Start(show_cursor);
  if (ret != 0) {
    LOG_ERROR("Start screen capturer failed: {}", ret);
  }
@@ -196,42 +314,19 @@ int SessionDeviceManager::StopScreenCapturer() {
  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());
-        });
+#ifdef _WIN32
+void SessionDeviceManager::ReleaseRemoteMouseButtons() {
+  if (auto mouse = dynamic_cast<PlatformMouseController*>(mouse_controller_))
+    mouse->ReleasePressedButtons();
+}
+#endif

-    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;
+void SessionDeviceManager::StartSpeakerCapturer() {
+  speaker_capture_.SetEnabled(true);
 }

-int SessionDeviceManager::StopSpeakerCapturer() {
-  if (speaker_capturer_) {
-    speaker_capturer_->Stop();
-    owner_.start_speaker_capturer_ = false;
-  }
-  return 0;
+void SessionDeviceManager::StopSpeakerCapturer() {
+  speaker_capture_.SetEnabled(false);
 }

 int SessionDeviceManager::StartMouseController() {
@@ -294,6 +389,7 @@ int SessionDeviceManager::StopMouseController() {
 }

 int SessionDeviceManager::StartKeyboardCapturer() {
+  ClearCapturedKeyboardInput();
  owner_.keyboard_capturer_uses_window_events_ = false;

 #ifdef __APPLE__
@@ -329,6 +425,7 @@ int SessionDeviceManager::StartKeyboardCapturer() {
      },
      this);
  if (hook_ret != 0) {
+    keyboard_capturer_->Unhook();
    owner_.keyboard_capturer_uses_window_events_ = true;
    LOG_WARN(
        "Start keyboard capturer failed, falling back to Slint keyboard events");
@@ -339,6 +436,9 @@ int SessionDeviceManager::StartKeyboardCapturer() {
 }

 int SessionDeviceManager::StopKeyboardCapturer() {
+  owner_.keyboard_capturer_is_started_ = false;
+  if (keyboard_capturer_) keyboard_capturer_->Unhook();
+  ClearCapturedKeyboardInput();
  if (owner_.keyboard_capturer_uses_window_events_) {
    owner_.keyboard_capturer_uses_window_events_ = false;
    LOG_INFO("Stop keyboard capturer with Slint keyboard backend");
@@ -346,8 +446,6 @@ int SessionDeviceManager::StopKeyboardCapturer() {
  }

  if (keyboard_capturer_) {
-    keyboard_capturer_->Unhook();
-    ClearCapturedKeyboardInput();
    LOG_INFO("Stop keyboard capturer");
  }
  return 0;
@@ -417,6 +515,15 @@ void SessionDeviceManager::PushAudio(const char *data, size_t size) {
 }

 void SessionDeviceManager::UpdateInteractions() {
+#ifdef _WIN32
+  if (owner_.screen_capturer_is_started_ &&
+      cursor_capture_dirty_.load(std::memory_order_relaxed)) {
+    if (auto* windows = dynamic_cast<ScreenCapturerWin*>(screen_capturer_)) {
+      cursor_capture_dirty_.store(false, std::memory_order_relaxed);
+      windows->SetCursorCapture(ShouldCaptureCursor());
+    }
+  }
+#endif
 #if defined(__linux__) && !defined(__APPLE__)
  const bool is_wayland_session = IsWaylandSession();
  const bool stop_wayland_mouse_before_screen =
@@ -441,16 +548,6 @@ void SessionDeviceManager::UpdateInteractions() {
    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;
@@ -461,7 +558,7 @@ void SessionDeviceManager::UpdateInteractions() {
    owner_.mouse_controller_is_started_ = false;
  }

-#if defined(__linux__) && !defined(__APPLE__)
+#if defined(__linux__) || defined(__APPLE__)
  if (owner_.screen_capturer_is_started_ && screen_capturer_ &&
      mouse_controller_) {
    const auto latest_display_info = screen_capturer_->GetDisplayInfoList();
@@ -477,6 +574,14 @@ void SessionDeviceManager::UpdateInteractions() {
      owner_.keyboard_capturer_is_started_ = true;
    }
    if (owner_.keyboard_capturer_is_started_) {
+      if (!owner_.keyboard_capturer_uses_window_events_ &&
+          (!keyboard_capturer_ || !keyboard_capturer_->IsHookActive())) {
+        StopKeyboardCapturer();
+        owner_.keyboard_.ForceReleasePressedKeys();
+        owner_.keyboard_capturer_uses_window_events_ = true;
+        owner_.keyboard_capturer_is_started_ = true;
+        LOG_WARN("Native keyboard capture stopped; using Slint keyboard events");
+      }
      DrainCapturedKeyboardInput();
      owner_.keyboard_.SendHeartbeat(false);
    }
@@ -508,6 +613,7 @@ void SessionDeviceManager::DrainCapturedKeyboardInput() {
    std::lock_guard<std::mutex> lock(captured_keyboard_inputs_mutex_);
    inputs.swap(captured_keyboard_inputs_);
  }
+  if (owner_.privacy_.Snapshot().input_blocked) return;
  for (const CapturedKeyboardInput &input : inputs) {
    owner_.keyboard_.SendKeyCommand(input.key_code, input.is_down,
                                    input.scan_code, input.extended);
@@ -549,6 +655,7 @@ SessionDeviceManager::display_info_list() const {
 }

 void SessionDeviceManager::DestroyDevices() {
+  speaker_capture_.Shutdown();
  if (mouse_controller_) {
    mouse_controller_->Destroy();
    delete mouse_controller_;
@@ -559,11 +666,6 @@ void SessionDeviceManager::DestroyDevices() {
    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;
@@ -573,8 +675,6 @@ void SessionDeviceManager::DestroyDevices() {
 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;
 }
@@ -1,8 +1,16 @@
-#ifndef CROSSDESK_GUI_SESSION_DEVICE_MANAGER_H_
-#define CROSSDESK_GUI_SESSION_DEVICE_MANAGER_H_
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-09
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _SESSION_DEVICE_MANAGER_H_
+#define _SESSION_DEVICE_MANAGER_H_
+

 #include <SDL3/SDL.h>

+#include <atomic>
 #include <chrono>
 #include <cstddef>
 #include <cstdint>
@@ -11,11 +19,13 @@
 #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"
+#include "speaker_capture_controller.h"

 namespace crossdesk {

@@ -27,17 +37,28 @@ class GuiRuntime;
 class SessionDeviceManager {
 public:
  explicit SessionDeviceManager(GuiRuntime &owner);
+  ~SessionDeviceManager();

  void Initialize();
  void UpdateInteractions();
+  // Call after changing the controller map. UpdateInteractions consumes this
+  // notification on the UI thread before reading the map under its mutex.
+  void OnControllerConnectionsChanged() {
+    cursor_capture_dirty_.store(true, std::memory_order_relaxed);
+  }
  void DestroyDevices();
  void DestroyFactories();

  int InitializeScreenCapturer();
  int StartScreenCapturer();
  int StopScreenCapturer();
-  int StartSpeakerCapturer();
-  int StopSpeakerCapturer();
+#ifdef _WIN32
+  void ReleaseRemoteMouseButtons();
+#endif
+  // Requests are asynchronous; Stop drains/revokes audio delivery before
+  // returning so the connection peer can be destroyed safely.
+  void StartSpeakerCapturer();
+  void StopSpeakerCapturer();
  int StartMouseController();
  int StopMouseController();
  int StartKeyboardCapturer();
@@ -69,13 +90,16 @@ private:
  void ClearCapturedKeyboardInput();
  bool ShouldSendCapturedFrame(std::chrono::steady_clock::time_point now,
                               int fps);
+  bool ShouldCaptureCursor() const;
+  void RecordCaptureCadence(std::chrono::steady_clock::time_point now, int fps,
+                            bool from_secure_desktop);

  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;
+  std::atomic<bool> cursor_capture_dirty_{true};
+  SpeakerCaptureController speaker_capture_;
  DeviceControllerFactory *device_controller_factory_ = nullptr;
  MouseController *mouse_controller_ = nullptr;
  KeyboardCapturer *keyboard_capturer_ = nullptr;
@@ -85,10 +109,18 @@ private:
  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::mutex capture_metrics_mutex_;
+  std::chrono::steady_clock::time_point capture_metrics_started_{};
+  std::chrono::steady_clock::time_point last_capture_callback_{};
+  uint64_t capture_callbacks_ = 0, capture_rate_drops_ = 0;
+  uint64_t capture_secure_callbacks_ = 0;
+  uint64_t capture_forwarded_ = 0, capture_send_errors_ = 0;
+  int64_t capture_max_gap_us_ = 0;
+  int64_t capture_send_us_ = 0, capture_max_send_us_ = 0;
  std::string last_video_frame_stream_id_;
  bool invalid_video_stream_id_logged_ = false;
 };

 } // namespace crossdesk

-#endif // CROSSDESK_GUI_SESSION_DEVICE_MANAGER_H_
+#endif
@@ -2,7 +2,6 @@

 #include <algorithm>
 #include <chrono>
-#include <cstring>
 #include <filesystem>
 #include <limits>
 #include <memory>
@@ -21,6 +20,16 @@ namespace crossdesk {

 FileTransferManager::FileTransferManager(GuiRuntime &owner) : owner_(owner) {}

+FileTransferManager::~FileTransferManager() {
+  std::vector<std::future<void>> workers;
+  {
+    std::lock_guard lock(workers_mutex_);
+    stopping_ = true;
+    workers.swap(workers_);
+  }
+  for (auto& worker : workers) worker.wait();
+}
+
 FileTransferManager::FileTransferState &FileTransferManager::global_state() {
  return global_state_;
 }
@@ -93,8 +102,16 @@ void FileTransferManager::Start(
    std::shared_ptr<RemoteSession> props,
    const std::filesystem::path &file_path, const std::string &file_label,
    const std::string &remote_id) {
+  if (props && props->closing_) return;
  const bool is_global = !props;
-  PeerPtr *peer = is_global ? owner_.peer_ : props->peer_;
+  PeerPtr* peer = nullptr;
+  std::shared_ptr<PeerEventHandler> peer_events;
+  {
+    std::shared_lock lock(owner_.remote_sessions_mutex_);
+    if (props && props->closing_) return;
+    peer = is_global ? owner_.peer_ : props->peer_;
+    peer_events = is_global ? owner_.peer_events_ : props->peer_events_;
+  }
  if (!peer) {
    LOG_ERROR("StartFileTransfer: invalid peer");
    return;
@@ -109,7 +126,14 @@ void FileTransferManager::Start(
  }

  const auto props_weak = std::weak_ptr<RemoteSession>(props);
-  std::thread([this, peer, file_path, file_label, props_weak, remote_id,
+  std::lock_guard workers_lock(workers_mutex_);
+  if (stopping_) return;
+  // Reap finished senders without blocking the UI.
+  std::erase_if(workers_, [](auto& worker) {
+    return worker.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
+  });
+  workers_.push_back(std::async(std::launch::async,
+      [this, peer, peer_events, file_path, file_label, props_weak, remote_id,
               is_global]() {
    auto props_locked = props_weak.lock();
    FileTransferState *state = nullptr;
@@ -167,7 +191,11 @@ void FileTransferManager::Start(

    const int ret = sender.SendFile(
        file_path, file_path.filename().string(),
-        [peer, file_label, remote_id](const char *buffer, size_t size) {
+        [peer, peer_events, file_label, remote_id, props_locked](const char *buffer, size_t size) {
+          // Close drains each in-flight send before detaching the peer.
+          if (props_locked && props_locked->closing_) return -1;
+          auto callback = peer_events->EnterCallback();
+          if (!callback) return -1;
          if (remote_id.empty()) {
            return SendReliableDataFrame(peer, buffer, size,
                                         file_label.c_str());
@@ -201,12 +229,13 @@ void FileTransferManager::Start(
    }
    LOG_ERROR("FileSender::SendFile failed for [{}], ret={}",
              file_path.string().c_str(), ret);
-    ProcessQueue(props_locked);
-  }).detach();
+    if (peer_events->IsActive()) ProcessQueue(props_locked);
+  }));
 }

 void FileTransferManager::ProcessQueue(
    std::shared_ptr<RemoteSession> props) {
+  if (props && props->closing_) return;
  FileTransferState &state = state_for(props);
  if (state.file_sending_.load()) {
    return;
@@ -236,15 +265,9 @@ void FileTransferManager::Unregister(uint32_t file_id, bool per_peer) {
 }

 void FileTransferManager::HandleAck(const char *data, size_t size) {
-  if (size < sizeof(FileTransferAck)) {
-    LOG_ERROR("FileTransferAck: buffer too small, size={}", size);
-    return;
-  }
-
  FileTransferAck ack{};
-  std::memcpy(&ack, data, sizeof(ack));
-  if (ack.magic != kFileAckMagic) {
-    LOG_ERROR("FileTransferAck: invalid magic, got 0x{:08X}", ack.magic);
+  if (!DecodeFileTransferAck(data, size, &ack)) {
+    LOG_ERROR("FileTransferAck: invalid payload, size={}", size);
    return;
  }

@@ -4,6 +4,9 @@
 #include <cstddef>
 #include <cstdint>
 #include <filesystem>
+#include <future>
+#include <mutex>
+#include <vector>
 #include <memory>
 #include <shared_mutex>
 #include <string>
@@ -21,6 +24,7 @@ public:
  using RemoteSession = gui_detail::RemoteSession;

  explicit FileTransferManager(GuiRuntime &owner);
+  ~FileTransferManager();

  FileTransferState &global_state();
  FileTransferState &
@@ -40,6 +44,9 @@ private:
  void ProcessQueue(std::shared_ptr<RemoteSession> props);
  void Unregister(uint32_t file_id, bool per_peer);

+  std::mutex workers_mutex_;
+  std::vector<std::future<void>> workers_;
+  bool stopping_ = false;
  GuiRuntime &owner_;
  FileTransferState global_state_;
  std::unordered_map<uint32_t, std::weak_ptr<RemoteSession>>
@@ -1,5 +1,7 @@
 #include "features/input/keyboard_controller.h"

+#include <remote_action.h>
+
 #include <SDL3/SDL.h>

 #include <cstdint>
@@ -148,6 +150,7 @@ void KeyboardController::SendHeartbeat(bool force) {
  const std::string target_id = owner_.controlled_remote_id_.empty()
                                    ? owner_.focused_remote_id_
                                    : owner_.controlled_remote_id_;
+  std::shared_lock sessions_lock(owner_.remote_sessions_mutex_);
  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() !=
@@ -187,6 +190,7 @@ int KeyboardController::SendKeyCommand(int key_code, bool is_down,
  const std::string target_id = owner_.controlled_remote_id_.empty()
                                    ? owner_.focused_remote_id_
                                    : owner_.controlled_remote_id_;
+  std::shared_lock sessions_lock(owner_.remote_sessions_mutex_);
  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() ==
@@ -209,6 +213,9 @@ int KeyboardController::SendKeyCommand(int key_code, bool is_down,
 bool KeyboardController::InjectRemoteKey(int key_code, bool is_down,
                                         uint32_t scan_code, bool extended) {
 #if _WIN32
+  if (owner_.privacy_.Engaged() && !IsWindowsPrivacyDesktopAvailable()) {
+    owner_.privacy_.Fail("Secure desktop or locked session; privacy screen will turn off");
+  }
  if (owner_.local_service_status_received_ &&
      IsSecureDesktopInteractionRequired(owner_.local_interactive_stage_)) {
    const std::string response = SendCrossDeskSecureDesktopKeyInput(
@@ -242,6 +249,7 @@ bool KeyboardController::InjectRemoteKey(int key_code, bool is_down,
    return true;
  }
 #endif
+  // Recheck after the desktop query; key-up cleanup remains allowed while paused.
  return owner_.devices_.SendKeyboardCommand(key_code, is_down, scan_code,
                                             extended);
 }
@@ -338,11 +346,50 @@ void KeyboardController::ReleaseRemotePressedKeys(const std::string& remote_id,
             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);
+    if (!InjectRemoteKey(key.key_code, false, key.scan_code, key.extended)) {
+#ifdef _WIN32
+      if (owner_.privacy_.Engaged()) {
+        std::lock_guard lock(remote_states_mutex_);
+        pending_privacy_releases_[key.key_code] = key;
+      }
+#endif
+    }
  }
 }

+void KeyboardController::ReleaseAllRemotePressedKeys(const char* reason) {
+  std::vector<std::string> remotes;
+  {
+    std::lock_guard lock(remote_states_mutex_);
+    for (const auto& [id, state] : remote_states_) remotes.push_back(id);
+  }
+  for (const auto& id : remotes) ReleaseRemotePressedKeys(id, reason);
+  CheckRemoteTimeouts();
+}
+
 void KeyboardController::CheckRemoteTimeouts() {
+#ifdef _WIN32
+  bool pending = false;
+  {
+    std::lock_guard lock(remote_states_mutex_);
+    pending = !pending_privacy_releases_.empty();
+  }
+  // A key-up rejected on the secure desktop is retained until the ordinary
+  // desktop returns. Never route cleanup through the security UI helper.
+  if (pending && IsWindowsPrivacyDesktopAvailable()) {
+    std::unordered_map<int, PressedKey> releases;
+    {
+      std::lock_guard lock(remote_states_mutex_);
+      releases.swap(pending_privacy_releases_);
+    }
+    for (const auto& [code, key] : releases) {
+      if (!owner_.devices_.SendKeyboardCommand(code, false, key.scan_code, key.extended)) {
+        std::lock_guard lock(remote_states_mutex_);
+        pending_privacy_releases_[code] = key;
+      }
+    }
+  }
+#endif
  const uint32_t now = static_cast<uint32_t>(SDL_GetTicks());
  std::vector<std::string> timed_out_remotes;
  {
@@ -6,6 +6,8 @@
 #include <string>
 #include <unordered_map>

+#include <remote_action.h>
+
 #include "device_controller.h"

 namespace crossdesk {
@@ -28,6 +30,7 @@ public:
                        const RemoteAction &remote_action);
  void ReleaseRemotePressedKeys(const std::string &remote_id,
                                const char *reason);
+  void ReleaseAllRemotePressedKeys(const char* reason);
  void CheckRemoteTimeouts();

 private:
@@ -56,6 +59,9 @@ private:
  uint32_t last_heartbeat_tick_ = 0;
  std::unordered_map<std::string, RemoteState> remote_states_;
  std::mutex remote_states_mutex_;
+#ifdef _WIN32
+  std::unordered_map<int, PressedKey> pending_privacy_releases_;
+#endif
 };

 } // namespace crossdesk
@@ -301,12 +301,13 @@ int SettingsManager::Load() {
      static_cast<int>(owner_.config_center_->GetVideoQuality());
  owner_.video_frame_rate_button_value_ =
      static_cast<int>(owner_.config_center_->GetVideoFrameRate());
+  owner_.video_adaptation_policy_button_value_ =
+      static_cast<int>(owner_.config_center_->GetVideoAdaptationPolicy());
  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();
@@ -324,12 +325,15 @@ int SettingsManager::Load() {

  owner_.language_button_value_last_ = owner_.language_button_value_;
  owner_.video_quality_button_value_last_ = owner_.video_quality_button_value_;
+  owner_.video_frame_rate_button_value_last_ =
+      owner_.video_frame_rate_button_value_;
+  owner_.video_adaptation_policy_button_value_last_ =
+      owner_.video_adaptation_policy_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_;

@@ -1,5 +1,11 @@
-#ifndef CROSSDESK_GUI_RENDER_H_
-#define CROSSDESK_GUI_RENDER_H_
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-04
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _RENDER_H_
+#define _RENDER_H_

 #include <memory>

@@ -25,4 +31,4 @@ private:

 } // namespace crossdesk

-#endif // CROSSDESK_GUI_RENDER_H_
+#endif
@@ -14,14 +14,14 @@
 #include "rd_log.h"

 #if defined(__APPLE__)
-#include "platform/metal_video_renderer.h"
+#include "platform/macos/gui/metal_video_renderer.h"
 #else
 #if defined(_WIN32)
 #include <windows.h>
 #endif
 #include <GL/gl.h>

-#include "platform/opengl_video_renderer.h"
+#include "platform/common/gui/opengl_video_renderer.h"
 #endif

 namespace crossdesk {
@@ -1,5 +1,11 @@
-#ifndef CROSSDESK_GUI_RENDERING_SLINT_VIDEO_PRESENTER_H_
-#define CROSSDESK_GUI_RENDERING_SLINT_VIDEO_PRESENTER_H_
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-04
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _SLINT_VIDEO_PRESENTER_H_
+#define _SLINT_VIDEO_PRESENTER_H_

 #include <cstddef>
 #include <cstdint>
@@ -72,4 +78,4 @@ private:

 }  // namespace crossdesk

-#endif  // CROSSDESK_GUI_RENDERING_SLINT_VIDEO_PRESENTER_H_
+#endif
@@ -6,49 +6,57 @@
 #include <shared_mutex>
 #include <string>
 #include <thread>
+#include <utility>
 #include <vector>

-#include "display_stream_id.h"
+#include <display_stream_id.h>
 #include "localization.h"
 #include "platform.h"
 #include "platform/video_renderer.h"
 #include "rd_log.h"
+#include "runtime/device_presence_request.h"
 #include "runtime/gui_runtime.h"

 namespace crossdesk {

 namespace {
 constexpr auto kPresenceProbeTimeout = std::chrono::seconds(5);
+constexpr auto kPresenceRefreshInterval = std::chrono::seconds(30);
+constexpr auto kPresenceRetryInterval = std::chrono::seconds(1);
 }  // namespace

+bool GuiRuntime::HasActiveSession() {
+  if (stream_window_inited_) return true;
+  std::shared_lock lock(connection_status_mutex_);
+  return std::any_of(connection_status_.begin(), connection_status_.end(),
+                     [](const auto& entry) {
+                       return entry.second == ConnectionStatus::Connecting ||
+                              entry.second == ConnectionStatus::Connected;
+                     });
+}
+
 void GuiRuntime::HandleConnectionStatusChange() {
-  if (signal_connected_ && peer_ && need_to_send_recent_connections_) {
-    if (!recent_connection_ids_.empty()) {
-      nlohmann::json j;
-      j["type"] = "recent_connections_presence";
-      j["user_id"] = client_id_;
-      j["devices"] = nlohmann::json::array();
-      for (const auto& id : recent_connection_ids_) {
-        std::string pure_id = id;
-        size_t pos_y = pure_id.find('Y');
-        size_t pos_n = pure_id.find('N');
-        size_t pos = std::string::npos;
-        if (pos_y != std::string::npos &&
-            (pos_n == std::string::npos || pos_y < pos_n)) {
-          pos = pos_y;
-        } else if (pos_n != std::string::npos) {
-          pos = pos_n;
-        }
-        if (pos != std::string::npos) {
-          pure_id = pure_id.substr(0, pos);
-        }
-        j["devices"].push_back(pure_id);
-      }
-      auto s = j.dump();
-      SendSignalMessage(peer_, s.data(), s.size());
-    }
+  if (!signal_connected_ || !peer_) {
+    return;
+  }
+  const auto now = std::chrono::steady_clock::now();
+  if (now - last_presence_request_attempt_at_ < kPresenceRetryInterval) {
+    return;
+  }
+  // Consume the flag before sending so a concurrent reconnect cannot lose its
+  // refresh request. Keep it pending while disconnected or after a send error.
+  const bool requested = need_to_send_recent_connections_.exchange(false);
+  if (!requested && now < next_presence_refresh_at_) {
+    return;
+  }
+  last_presence_request_attempt_at_ = now;
+  const auto message =
+      BuildDevicePresenceRequest(client_id_, recent_connection_ids_, true).dump();
+  if (SendSignalMessage(peer_, message.data(), message.size()) == 0) {
+    next_presence_refresh_at_ = now + kPresenceRefreshInterval;
+  } else {
+    need_to_send_recent_connections_ = true;
  }
-  need_to_send_recent_connections_ = false;
 }

 void GuiRuntime::HandlePendingPresenceProbe() {
@@ -123,32 +131,41 @@ void GuiRuntime::HandlePresenceProbeTimeout() {
 void GuiRuntime::HandleServerControllerDisconnected(
    const std::string& remote_id, const char* reason) {
  keyboard_.ReleaseRemotePressedKeys(remote_id, reason);
+#ifdef _WIN32
+  devices_.ReleaseRemoteMouseButtons();
+#endif
+  {
+    std::lock_guard lock(remote_pointer_input_mutex_);
+    last_remote_pointer_input_time_.erase(remote_id);
+  }

  bool has_connected_controller = false;
-  bool has_web_controller = false;
  std::string remaining_controller_id;
  {
    std::unique_lock lock(connection_status_mutex_);
    connection_status_.erase(remote_id);
+    devices_.OnControllerConnectionsChanged();
    connection_host_names_.erase(remote_id);
+    privacy_sessions_.Disconnected(remote_id);
    for (const auto& [id, status] : connection_status_) {
      if (status != ConnectionStatus::Connected) {
        continue;
      }
      has_connected_controller = true;
-      has_web_controller =
-          has_web_controller || id.find("web") != std::string::npos;
      if (remaining_controller_id.empty()) {
        remaining_controller_id = id;
      }
    }
  }
-  show_cursor_ = has_web_controller;
  if (has_connected_controller) {
    remote_client_id_ = remaining_controller_id;
    return;
  }

+  LOG_INFO("Last remote controller disconnected; recovering privacy, reason={}",
+           reason ? reason : "unknown");
+  privacy_.Disconnected();
+
  need_to_create_server_window_.store(false, std::memory_order_release);
  need_to_destroy_server_window_.store(true, std::memory_order_release);
  is_server_mode_ = false;
@@ -166,14 +183,11 @@ void GuiRuntime::HandleServerControllerDisconnected(
 #else
  start_screen_capturer_ = false;
 #endif
-  start_speaker_capturer_ = false;
+  devices_.StopSpeakerCapturer();
  start_mouse_controller_ = false;
  start_keyboard_capturer_ = false;
  remote_client_id_.clear();
-  if (audio_capture_) {
-    devices_.StopSpeakerCapturer();
-    audio_capture_ = false;
-  }
+  audio_capture_ = false;
  devices_.ResetToInitialDisplay();
 }

@@ -195,11 +209,9 @@ int GuiRuntime::RequestSingleDevicePresence(const std::string& remote_id,
    pending_presence_remember_password_ = remember_password;
  }

-  nlohmann::json j;
-  j["type"] = "recent_connections_presence";
-  j["user_id"] = client_id_;
-  j["devices"] = nlohmann::json::array({remote_id});
-  auto s = j.dump();
+  const auto s = BuildDevicePresenceRequest(
+                     client_id_, recent_connection_ids_, false, remote_id)
+                     .dump();

  int ret = SendSignalMessage(peer_, s.data(), s.size());
  if (ret != 0) {
@@ -216,6 +228,11 @@ int GuiRuntime::RequestSingleDevicePresence(const std::string& remote_id,
 }

 void GuiRuntime::CloseRemoteSession(std::shared_ptr<RemoteSession> props) {
+  if (!props || props->closing_.exchange(true)) return;
+  if (props->peer_events_) props->peer_events_->Deactivate();
+  props->connection_established_ = false;
+  props->streaming_ = false;
+  props->connection_status_.store(ConnectionStatus::Closed);
  std::shared_ptr<std::vector<unsigned char>> frame_snapshot;
  int video_width = 0;
  int video_height = 0;
@@ -241,85 +258,161 @@ void GuiRuntime::CloseRemoteSession(std::shared_ptr<RemoteSession> props) {
    }
  }

-  if (frame_snapshot && !frame_snapshot->empty() && video_width > 0 &&
-      video_height > 0) {
-    std::vector<unsigned char> buffer_copy(*frame_snapshot);
-    std::string remote_id = props->remote_id_;
-    std::string remote_host_name = props->remote_host_name_;
-    std::string password =
-        props->remember_password_ ? props->remote_password_ : "";
-
-    std::thread save_thread([buffer_copy, video_width, video_height, remote_id,
-                             remote_host_name, password,
-                             thumbnail = thumbnail_]() {
-      thumbnail->SaveToThumbnail((char*)buffer_copy.data(), video_width,
-                                 video_height, remote_id, remote_host_name,
-                                 password);
-    });
-
-    {
-      std::lock_guard<std::mutex> lock(thumbnail_save_threads_mutex_);
-      thumbnail_save_threads_.emplace_back(std::move(save_thread));
-    }
-  }
-
  if (native_renderer) {
    native_renderer->DiscardStream(props->remote_id_);
    video_frame_dirty_.store(true, std::memory_order_release);
  }

-  if (props->peer_) {
-    LOG_INFO("[{}] Leave connection [{}]", props->local_id_, props->remote_id_);
-    LeaveConnection(props->peer_, props->remote_id_.c_str());
-    LOG_INFO("Destroy peer [{}]", props->local_id_);
-    DestroyPeer(&props->peer_);
+  PeerPtr* peer = nullptr;
+  {
+    // Audio/clipboard senders hold a shared map lock while using this pointer.
+    std::unique_lock lock(remote_sessions_mutex_);
+    peer = std::exchange(props->peer_, nullptr);
  }
+  const auto queued_at = std::chrono::steady_clock::now();
+  session_cleanup_tasks_[props->remote_id_] = session_cleanup_queue_.PostTask(
+      [props, peer, frame_snapshot, video_width, video_height,
+       thumbnail = thumbnail_, queued_at]() mutable {
+        if (peer) {
+          LOG_INFO("[{}] Background leave connection [{}]", props->local_id_,
+                   props->remote_id_);
+          LeaveConnection(peer, props->remote_id_.c_str());
+          DestroyPeer(&peer);
+        }
+        if (thumbnail && frame_snapshot && !frame_snapshot->empty() &&
+            video_width > 0 && video_height > 0) {
+          thumbnail->SaveToThumbnail(
+              reinterpret_cast<char*>(frame_snapshot->data()), video_width,
+              video_height, props->remote_id_, props->remote_host_name_,
+              props->remember_password_ ? props->remote_password_ : "");
+        }
+        const auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::steady_clock::now() - queued_at).count();
+        LOG_INFO("[{}] Session cleanup completed in {} ms", props->remote_id_,
+                 elapsed);
+      });
+}
+
+void GuiRuntime::CloseServerController(const std::string& remote_id) {
+  if (!peer_ || remote_id.empty() || controller_cleanup_tasks_.count(remote_id))
+    return;
+  controller_cleanup_tasks_[remote_id] = session_cleanup_queue_.PostTask(
+      [peer = peer_, remote_id] { LeaveConnection(peer, remote_id.c_str()); });
+}
+
+void GuiRuntime::CloseConnectionPeer() {
+  if (!peer_) return;
+  peer_events_->Deactivate();
+  std::vector<std::string> controllers;
+  {
+    std::shared_lock lock(connection_status_mutex_);
+    for (const auto& [id, status] : connection_status_) controllers.push_back(id);
+  }
+  for (const auto& id : controllers)
+    HandleServerControllerDisconnected(id, "peer_closed");
+  devices_.StopMouseController();
+  devices_.StopScreenCapturer();
+  devices_.StopSpeakerCapturer();
+  devices_.StopKeyboardCapturer();
+  signal_connected_ = false;
+  device_presence_cache_.SetSignalConnected(false);
+  signal_status_ = SignalStatus::SignalClosed;
+  PeerPtr* peer;
+  {
+    std::unique_lock lock(remote_sessions_mutex_);
+    peer = std::exchange(peer_, nullptr);
+  }
+  // The same serial queue also owns outstanding controller disconnects, so
+  // these finish before the shared peer is destroyed.
+  connection_peer_cleanup_ = session_cleanup_queue_.PostTask(
+      [peer, handler = peer_events_, id = std::string(client_id_)]() mutable {
+        LOG_INFO("[{}] Background connection peer cleanup", id);
+        LeaveConnection(peer, id.c_str());
+        DestroyPeer(&peer);
+      });
 }

 void GuiRuntime::CloseAllRemoteSessions() {
-  if (peer_) {
-    LOG_INFO("[{}] Leave connection [{}]", client_id_, client_id_);
-    LeaveConnection(peer_, client_id_);
-    is_client_mode_ = false;
-    devices_.StopMouseController();
-    devices_.StopScreenCapturer();
-    devices_.StopSpeakerCapturer();
-    devices_.StopKeyboardCapturer();
-    LOG_INFO("Destroy peer [{}]", client_id_);
-    DestroyPeer(&peer_);
-  }
-
+  CloseConnectionPeer();
+  is_client_mode_ = false;
+  pending_reconnects_.clear();
+  std::vector<std::shared_ptr<RemoteSession>> sessions;
  {
-    // std::shared_lock lock(remote_sessions_mutex_);
-    for (auto& it : remote_sessions_) {
-      auto props = it.second;
-      CloseRemoteSession(props);
-    }
+    std::shared_lock lock(remote_sessions_mutex_);
+    for (const auto& [id, props] : remote_sessions_) sessions.push_back(props);
  }
-
+  for (const auto& props : sessions) CloseRemoteSession(props);
  {
-    // std::unique_lock lock(remote_sessions_mutex_);
+    std::unique_lock lock(remote_sessions_mutex_);
    remote_sessions_.clear();
  }
 }

-void GuiRuntime::WaitForThumbnailSaveTasks() {
-  std::vector<std::thread> threads_to_join;
-
-  {
-    std::lock_guard<std::mutex> lock(thumbnail_save_threads_mutex_);
-    threads_to_join.swap(thumbnail_save_threads_);
+void GuiRuntime::HandleSessionCleanup() {
+  auto completed = [](std::future<void>& task) {
+    if (!task.valid() || task.wait_for(std::chrono::seconds(0)) !=
+                             std::future_status::ready) return false;
+    try {
+      task.get();
+    } catch (const std::exception& error) {
+      LOG_ERROR("Connection cleanup failed: {}", error.what());
+    }
+    return true;
+  };
+  completed(connection_peer_cleanup_);
+  for (auto it = controller_cleanup_tasks_.begin();
+       it != controller_cleanup_tasks_.end();) {
+    if (completed(it->second)) it = controller_cleanup_tasks_.erase(it);
+    else ++it;
  }
-
-  if (threads_to_join.empty()) {
-    return;
+  std::vector<std::pair<std::string, PendingReconnect>> reconnects;
+  for (auto it = session_cleanup_tasks_.begin();
+       it != session_cleanup_tasks_.end();) {
+    if (it->second.wait_for(std::chrono::seconds(0)) !=
+        std::future_status::ready) {
+      ++it;
+      continue;
+    }
+    try {
+      it->second.get();
+    } catch (const std::exception& error) {
+      LOG_ERROR("[{}] Session cleanup failed: {}", it->first, error.what());
+    }
+    if (auto pending = pending_reconnects_.find(it->first);
+        pending != pending_reconnects_.end()) {
+      reconnects.emplace_back(pending->first, std::move(pending->second));
+      pending_reconnects_.erase(pending);
+    }
+    it = session_cleanup_tasks_.erase(it);
+    reload_recent_connections_ = true;
+    recent_connection_image_save_time_ = 0;
  }
+  for (const auto& [id, request] : reconnects) {
+    ConnectTo(id, request.password.c_str(), request.remember_password);
+  }
+}

-  for (auto& thread : threads_to_join) {
-    if (thread.joinable()) {
-      thread.join();
+void GuiRuntime::WaitForSessionCleanup() {
+  pending_reconnects_.clear();
+  auto drain = [](std::future<void>& task) {
+    if (!task.valid()) return;
+    try {
+      task.get();
+    } catch (const std::exception& error) {
+      LOG_ERROR("Connection cleanup failed: {}", error.what());
+    }
+  };
+  drain(connection_peer_cleanup_);
+  for (auto& [id, task] : controller_cleanup_tasks_) drain(task);
+  controller_cleanup_tasks_.clear();
+  for (auto& [id, task] : session_cleanup_tasks_) {
+    try {
+      task.get();
+    } catch (const std::exception& error) {
+      LOG_ERROR("[{}] Session cleanup failed: {}", id, error.what());
    }
  }
+  session_cleanup_tasks_.clear();
 }

 void GuiRuntime::ResetRemoteSessionResources(
@@ -342,6 +435,7 @@ void GuiRuntime::ResetRemoteSessionResources(
    std::lock_guard<std::mutex> lock(props->remote_cursor_state_mutex_);
    props->remote_cursor_state_ = {};
    props->remote_cursor_state_received_ = false;
+    props->cursor_presentation_ = {};
  }
 }

@@ -361,6 +455,11 @@ std::shared_ptr<GuiRuntime::RemoteSession> GuiRuntime::FindRemoteSession(

 int GuiRuntime::ConnectTo(const std::string& remote_id, const char* password,
                          bool remember_password, bool bypass_presence_check) {
+  if (session_cleanup_tasks_.count(remote_id)) {
+    pending_reconnects_[remote_id] = {password ? password : "", remember_password};
+    LOG_INFO("[{}] Reconnect queued until previous peer is destroyed", remote_id);
+    return 0;
+  }
  if (!bypass_presence_check && !device_presence_cache_.IsOnline(remote_id)) {
    int ret =
        RequestSingleDevicePresence(remote_id, password, remember_password);
@@ -378,16 +477,14 @@ int GuiRuntime::ConnectTo(const std::string& remote_id, const char* password,
  LOG_INFO("Connect to [{}]", remote_id);
  focused_remote_id_ = remote_id;

-  // std::shared_lock shared_lock(remote_sessions_mutex_);
-  bool exists = (remote_sessions_.find(remote_id) != remote_sessions_.end());
-  // shared_lock.unlock();
+  bool exists = FindRemoteSession(remote_id) != nullptr;

  if (!exists) {
    PeerPtr* peer_to_init = nullptr;
    std::string local_id;

    {
-      // std::unique_lock unique_lock(remote_sessions_mutex_);
+      std::unique_lock unique_lock(remote_sessions_mutex_);
      if (remote_sessions_.find(remote_id) == remote_sessions_.end()) {
        remote_sessions_[remote_id] = std::make_shared<RemoteSession>();
        auto props = remote_sessions_[remote_id];
@@ -395,6 +492,8 @@ int GuiRuntime::ConnectTo(const std::string& remote_id, const char* password,
        props->remote_id_ = remote_id;
        memcpy(&props->params_, &params_, sizeof(Params));
        props->params_.user_id = props->local_id_.c_str();
+        props->peer_events_ = std::make_shared<PeerEventHandler>(*this);
+        props->params_.user_data = props->peer_events_.get();
        props->peer_ = CreatePeer(&props->params_);

        props->control_window_width_ = title_bar_height_ * 10.0f;
@@ -419,7 +518,7 @@ int GuiRuntime::ConnectTo(const std::string& remote_id, const char* password,
        }
        AddAudioStream(props->peer_, props->audio_label_.c_str());
        AddDataStream(props->peer_, props->data_label_.c_str(), false);
-        AddDataStream(props->peer_, props->mouse_label_.c_str(), false);
+        AddDataStream(props->peer_, props->mouse_label_.c_str(), true);
        AddDataStream(props->peer_, props->keyboard_label_.c_str(), true);
        AddDataStream(props->peer_, props->control_data_label_.c_str(), true);
        AddDataStream(props->peer_, props->file_label_.c_str(), true);
@@ -441,8 +540,8 @@ int GuiRuntime::ConnectTo(const std::string& remote_id, const char* password,
  }

  int ret = -1;
-  // std::shared_lock read_lock(remote_sessions_mutex_);
-  auto props = remote_sessions_[remote_id];
+  auto props = FindRemoteSession(remote_id);
+  if (!props || props->closing_) return -1;
  if (!props->connection_established_) {
    props->connection_status_.store(ConnectionStatus::Connecting);
    show_connection_status_window_ = true;
@@ -466,7 +565,6 @@ int GuiRuntime::ConnectTo(const std::string& remote_id, const char* password,
      }
    }
  }
-  // read_lock.unlock();

  return 0;
 }
@@ -0,0 +1,73 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-04
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _CURSOR_POSITION_H_
+#define _CURSOR_POSITION_H_
+
+#include <algorithm>
+#include <vector>
+
+#include <remote_action.h>
+
+#include "display_info.h"
+
+namespace crossdesk {
+
+inline void ResetCursorPosition(CursorState* state) {
+  if (!state) return;
+  state->position_update = true;
+  state->position_valid = false;
+  state->x = 0.5f;
+  state->y = 0.5f;
+  state->visual_offset_x = 0.0f;
+  state->visual_offset_y = 0.0f;
+  state->display_id = -1;
+}
+
+inline bool NormalizeCursorPosition(
+    double screen_x, double screen_y,
+    const std::vector<DisplayInfo>& displays, int preferred_display,
+    CursorState* state) {
+  if (!state) return false;
+  ResetCursorPosition(state);
+
+  auto contains = [&](int index) {
+    if (index < 0 || index >= static_cast<int>(displays.size())) return false;
+    const auto& display = displays[index];
+    return display.width > 0 && display.height > 0 &&
+           screen_x >= display.left && screen_x < display.right &&
+           screen_y >= display.top && screen_y < display.bottom;
+  };
+
+  int display_id = contains(preferred_display) ? preferred_display : -1;
+  if (display_id < 0) {
+    for (int index = 0; index < static_cast<int>(displays.size()); ++index) {
+      if (contains(index)) {
+        display_id = index;
+        break;
+      }
+    }
+  }
+  if (display_id < 0) return false;
+
+  const auto& display = displays[display_id];
+  // Screen coordinates describe a continuous rectangle with an exclusive
+  // right/bottom edge. Use its full extent so feedback is the exact inverse of
+  // normalized input instead of accumulating a one-pixel edge convention.
+  const double horizontal_extent = std::max(display.width, 1);
+  const double vertical_extent = std::max(display.height, 1);
+  state->position_valid = true;
+  state->x = static_cast<float>(std::clamp(
+      (screen_x - display.left) / horizontal_extent, 0.0, 1.0));
+  state->y = static_cast<float>(std::clamp(
+      (screen_y - display.top) / vertical_extent, 0.0, 1.0));
+  state->display_id = display_id;
+  return true;
+}
+
+}  // namespace crossdesk
+
+#endif
@@ -0,0 +1,77 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-16
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _CURSOR_PRESENTATION_H_
+#define _CURSOR_PRESENTATION_H_
+
+#include <remote_action.h>
+
+#include <cstdint>
+#include <optional>
+
+namespace crossdesk {
+
+// All times use one monotonic millisecond clock. The owning session's cursor
+// mutex protects this policy from the transport and UI threads.
+class CursorPresentation {
+ public:
+  static constexpr uint64_t kStateTimeoutMs = 1500;  // Three 500ms heartbeats.
+  static constexpr uint64_t kInputActivityMs = 1500;
+
+  void Observe(const CursorState& state, uint64_t now) {
+    if (state.render_mode == CursorRenderMode::unknown) {
+      // Repeated unavailable samples must not extend the recovery deadline.
+      if (!sample_unavailable_) stale_at_ = now + kStateTimeoutMs;
+      sample_unavailable_ = true;
+      return;
+    }
+    sample_unavailable_ = false;
+    stale_at_ = now + kStateTimeoutMs;
+    const bool separate =
+        state.render_mode == CursorRenderMode::separate ||
+        (state.render_mode == CursorRenderMode::legacy && state.visible);
+    // Old senders cannot distinguish embedded from hidden. Only explicit
+    // metadata from a new sender can establish the no-device compatibility
+    // case.
+    no_device_ = state.render_mode == CursorRenderMode::hidden &&
+                 state.hidden_reason == CursorHiddenReason::no_pointing_device;
+    held_shape_ = separate ? state.shape : RemoteCursorShape::none;
+    if (held_shape_ != RemoteCursorShape::none) {
+      last_visible_shape_ = held_shape_;
+    }
+    if (!no_device_) fallback_engaged_ = false;
+  }
+
+  void NoteInput(uint64_t now) { last_input_ = now; }
+
+  RemoteCursorShape Resolve(uint64_t now) {
+    if (!stale_at_) return RemoteCursorShape::default_cursor;
+
+    const bool recent_input =
+        last_input_ && now - *last_input_ < kInputActivityMs;
+    const bool can_recover =
+        now >= *stale_at_ || (!sample_unavailable_ && no_device_);
+    if (can_recover && recent_input) {
+      fallback_engaged_ = true;
+    }
+    // Once needed, retain the locator while idle until a good non-compatibility
+    // sample arrives. Otherwise it would blink off whenever input pauses.
+    return fallback_engaged_ ? last_visible_shape_ : held_shape_;
+  }
+
+ private:
+  bool sample_unavailable_ = false;
+  bool no_device_ = false;
+  bool fallback_engaged_ = false;
+  std::optional<uint64_t> stale_at_;
+  std::optional<uint64_t> last_input_;
+  RemoteCursorShape held_shape_ = RemoteCursorShape::default_cursor;
+  RemoteCursorShape last_visible_shape_ = RemoteCursorShape::default_cursor;
+};
+
+}  // namespace crossdesk
+
+#endif
@@ -0,0 +1,137 @@
+#include "runtime/cursor_state_provider.h"
+
+#include <remote_action.h>
+
+#if defined(_WIN32)
+
+#include <windows.h>
+
+#include "platform/windows/input/windows_cursor_state.h"
+#include "platform/windows/screen_capturer/captured_cursor_state.h"
+#include "platform/windows/screen_capturer/dxgi_cursor_state.h"
+#include "platform/windows/screen_capturer/secure_desktop_cursor_state.h"
+#include "runtime/cursor_position.h"
+
+namespace crossdesk {
+
+struct CursorStateProvider::Impl {
+  WindowsCursorState cursor;
+};
+
+CursorStateProvider::CursorStateProvider() : impl_(std::make_unique<Impl>()) {}
+CursorStateProvider::~CursorStateProvider() = default;
+
+bool CursorStateProvider::Sample(const std::vector<DisplayInfo>& displays,
+                                 int preferred_display, CursorState* state) {
+  if (!state) return false;
+
+  SecureDesktopCursorSnapshot secure_cursor{};
+  if (SharedSecureDesktopCursorState().Get(&secure_cursor)) {
+    if (!secure_cursor.valid) {
+      state->hidden_reason = CursorHiddenReason::secure_desktop_pending;
+      return false;
+    }
+    state->seq = 0;
+    NormalizeCursorPosition(secure_cursor.x, secure_cursor.y, displays,
+                            preferred_display, state);
+    state->visible = secure_cursor.visible != 0;
+    state->render_mode = static_cast<CursorRenderMode>(secure_cursor.render_mode);
+    state->hidden_reason =
+        static_cast<CursorHiddenReason>(secure_cursor.hidden_reason);
+    state->shape = state->visible
+                       ? static_cast<RemoteCursorShape>(secure_cursor.shape)
+                       : RemoteCursorShape::none;
+    return true;
+  }
+
+  CURSORINFO info{};
+  info.cbSize = sizeof(info);
+  if (!GetCursorInfo(&info)) return false;
+
+  state->seq = 0;
+  NormalizeCursorPosition(info.ptScreenPos.x, info.ptScreenPos.y, displays,
+                          preferred_display, state);
+  void* cursor_monitor = state->position_valid
+                             ? displays[state->display_id].handle
+                             : nullptr;
+  const bool embedded = SharedCapturedCursorState().IsEmbedded(cursor_monitor) ||
+      ((info.flags & CURSOR_SHOWING) != 0 &&
+       !SharedDxgiCursorState().ShouldDrawCursor(true, cursor_monitor));
+  impl_->cursor.Sample(info, embedded, state);
+  return true;
+}
+
+}  // namespace crossdesk
+
+#elif defined(__linux__) && !defined(__APPLE__)
+
+#include <X11/Xlib.h>
+#include <X11/extensions/Xfixes.h>
+
+#include <string>
+
+#include "linux_cursor_shape.h"
+#include "platform.h"
+#include "shared_cursor_state.h"
+#include "runtime/cursor_position.h"
+
+namespace crossdesk {
+namespace {
+
+bool CursorHasVisiblePixel(const XFixesCursorImage& image) {
+  const size_t pixel_count =
+      static_cast<size_t>(image.width) * static_cast<size_t>(image.height);
+  for (size_t index = 0; index < pixel_count; ++index) {
+    if (((image.pixels[index] >> 24U) & 0xffU) != 0) return true;
+  }
+  return false;
+}
+
+}  // namespace
+
+struct CursorStateProvider::Impl {
+  Display* display = XOpenDisplay(nullptr);
+
+  ~Impl() {
+    if (display) XCloseDisplay(display);
+  }
+};
+
+CursorStateProvider::CursorStateProvider() : impl_(std::make_unique<Impl>()) {}
+CursorStateProvider::~CursorStateProvider() = default;
+
+bool CursorStateProvider::Sample(const std::vector<DisplayInfo>& displays,
+                                 int preferred_display, CursorState* state) {
+  if (!state || !impl_) return false;
+  ResetCursorPosition(state);
+
+  if (IsWaylandSession()) {
+    SharedCursorState shared{};
+    if (GetSharedCursorState(&shared)) {
+      state->seq = 0;
+      state->visible = shared.visible;
+      state->shape = shared.visible ? shared.shape : RemoteCursorShape::none;
+      return true;
+    }
+  }
+
+  if (!impl_->display) return false;
+
+  XFixesCursorImage* image = XFixesGetCursorImage(impl_->display);
+  if (!image) return false;
+
+  const std::string name = image->name ? image->name : "";
+
+  state->seq = 0;
+  state->visible = CursorHasVisiblePixel(*image);
+  state->shape = state->visible ? ShapeFromLinuxCursorName(name)
+                                : RemoteCursorShape::none;
+  NormalizeCursorPosition(image->x, image->y, displays, preferred_display,
+                          state);
+  XFree(image);
+  return true;
+}
+
+}  // namespace crossdesk
+
+#endif
@@ -1,9 +1,18 @@
-#ifndef CROSSDESK_GUI_CURSOR_STATE_PROVIDER_H_
-#define CROSSDESK_GUI_CURSOR_STATE_PROVIDER_H_
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-04
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _CURSOR_STATE_PROVIDER_H_
+#define _CURSOR_STATE_PROVIDER_H_

 #include <memory>
+#include <vector>

-#include "device_controller.h"
+#include <remote_action.h>
+
+#include "display_info.h"

 namespace crossdesk {

@@ -17,7 +26,8 @@ class CursorStateProvider {
  CursorStateProvider(const CursorStateProvider&) = delete;
  CursorStateProvider& operator=(const CursorStateProvider&) = delete;

-  bool Sample(CursorState* state);
+  bool Sample(const std::vector<DisplayInfo>& displays,
+              int preferred_display, CursorState* state);

 private:
  struct Impl;
@@ -26,4 +36,4 @@ class CursorStateProvider {

 }  // namespace crossdesk

-#endif  // CROSSDESK_GUI_CURSOR_STATE_PROVIDER_H_
+#endif
@@ -0,0 +1,61 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-04
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _DEVICE_PRESENCE_CACHE_H_
+#define _DEVICE_PRESENCE_CACHE_H_
+
+#include <chrono>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+namespace crossdesk {
+
+class DevicePresenceCache {
+public:
+  using Clock = std::chrono::steady_clock;
+  static constexpr auto kMaxAge = std::chrono::seconds(60);
+
+  void SetSignalConnected(bool connected) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    signal_connected_ = connected;
+    cache_.clear();
+  }
+
+  void SetOnline(const std::string &device_id, bool online,
+                 Clock::time_point now = Clock::now()) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (signal_connected_) {
+      cache_[device_id] = {online, now};
+    }
+  }
+
+  bool IsOnline(const std::string &device_id,
+                Clock::time_point now = Clock::now()) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    const auto it = cache_.find(device_id);
+    return signal_connected_ && it != cache_.end() && it->second.online &&
+           now - it->second.updated_at < kMaxAge;
+  }
+
+  void Clear() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    cache_.clear();
+  }
+
+private:
+  struct Entry {
+    bool online;
+    Clock::time_point updated_at;
+  };
+  bool signal_connected_ = false;
+  std::unordered_map<std::string, Entry> cache_;
+  mutable std::mutex mutex_;
+};
+
+} // namespace crossdesk
+
+#endif
@@ -0,0 +1,43 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-07
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _DEVICE_PRESENCE_REQUEST_H_
+#define _DEVICE_PRESENCE_REQUEST_H_
+
+#include <algorithm>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <vector>
+
+namespace crossdesk {
+
+inline nlohmann::json BuildDevicePresenceRequest(
+    const std::string& client_id, const std::vector<std::string>& recent_ids,
+    bool subscribe, const std::string& probe_id = {}) {
+  std::vector<std::string> devices;
+  for (const auto& id : recent_ids) {
+    // Recent connection keys contain Y/N plus display settings after the ID.
+    const std::string pure_id = id.substr(0, id.find_first_of("YN"));
+    if (!pure_id.empty() &&
+        std::find(devices.begin(), devices.end(), pure_id) == devices.end()) {
+      devices.push_back(pure_id);
+    }
+  }
+  if (!probe_id.empty() &&
+      std::find(devices.begin(), devices.end(), probe_id) == devices.end()) {
+    devices.push_back(probe_id);
+  }
+  // Include recent devices even in a one-shot probe: older servers ignore
+  // subscribe=false and replace their subscriptions with this device list.
+  return {{"type", "recent_connections_presence"},
+          {"user_id", client_id},
+          {"devices", devices},
+          {"subscribe", subscribe}};
+}
+
+}  // namespace crossdesk
+
+#endif
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
dijunkun	e263aab10d	[fix] keep Windows privacy screen active when running as administrator	2026-09-17 09:55:34 +08:00
dijunkun	9abdfbf684	[release] prepare v1.5.1 release notes	2026-09-17 02:56:49 +08:00
dijunkun	31a0b86cee	[fix] refine network stats layout and alignment	2026-09-17 02:45:35 +08:00
dijunkun	fb34f42744	[fix] show encryption status and simplify network stats labels	2026-09-17 02:01:55 +08:00
dijunkun	4302ab291c	[fix] overlay control bar tooltips on expanded network stats	2026-09-17 01:39:09 +08:00
dijunkun	4bf92c9e2c	[fix] use reliable transport for mouse input and cursor state	2026-09-17 01:31:54 +08:00
dijunkun	28de4cf938	[fix] improve Windows taskbar icon clarity at small sizes	2026-09-16 23:19:12 +08:00
dijunkun	ce7a3c178e	[fix] correct WGC and GDI cursor capture and positioning	2026-09-16 23:03:36 +08:00
dijunkun	d9116200fe	[fix] restore remote cursors on Windows without a physical mouse	2026-09-16 22:20:36 +08:00
dijunkun	1d9242515a	[fix] restore remote cursor visibility during Windows privacy screen	2026-09-16 20:27:59 +08:00
dijunkun	ad62e60b9a	[fix] restore shared capture on Windows secure desktop	2026-09-16 15:31:27 +08:00
dijunkun	c4aca303c8	[fix] restore cursor visibility on Windows lock screen	2026-09-16 14:48:39 +08:00
dijunkun	57bb91dba3	[fix] prevent duplicate cursors during Windows window dragging	2026-09-16 13:51:35 +08:00
dijunkun	57cab3979e	[fix] initialize logging before startup operations and update MiniRTC	2026-09-16 12:54:07 +08:00
dijunkun	d8ccdbaa38	[fix] add capture delivery diagnostics	2026-09-16 12:54:06 +08:00
dijunkun	f3e67d7d6e	[fix] recognize macOS window resize cursors	2026-09-15 16:44:19 +08:00
dijunkun	d648585891	[fix] restore Linux X11 remote keyboard capture	2026-09-15 16:23:42 +08:00
dijunkun	e40c7fca98	[fix] disable privacy screen for legacy and web clients	2026-09-15 13:04:53 +08:00
dijunkun	f6324416ec	[fix] update MiniRTC legacy DTLS-SRTP compatibility	2026-09-15 12:20:00 +08:00
dijunkun	0977bd4195	[fix] update MiniRTC SRTP replay handling and bandwidth accounting	2026-09-15 03:38:29 +08:00
dijunkun	f4e094cb35	[fix] update MiniRTC packet validation and SRTP buffering	2026-09-15 03:16:18 +08:00
dijunkun	1fe706c5fc	[fix] update MiniRTC SRTP initialization	2026-09-15 03:03:47 +08:00
dijunkun	5fd928ddba	[fix] update MiniRTC DTLS-SRTP key layout and profiles	2026-09-15 02:53:25 +08:00
dijunkun	977899b240	[feat] enable iOS punching and preserve connection errors	2026-09-15 02:37:30 +08:00
dijunkun	7fc1344756	[feat] enable enhanced UDP punching on desktop	2026-09-15 02:37:30 +08:00
dijunkun	73e3bf709d	[perf] exclude optional libaom from default builds	2026-09-13 06:43:29 +08:00
dijunkun	6d90c28513	[perf] strip packaged Slint runtime symbols	2026-09-13 06:39:26 +08:00
dijunkun	c944db6519	[perf] scope desktop build variant and version defines	2026-09-13 06:39:23 +08:00
dijunkun	fc921c9ca1	[perf] avoid redundant iOS native archive rebuilds	2026-09-13 06:36:05 +08:00
dijunkun	ba2afc982b	[fix] repair macOS Intel OpenH264 CI build	2026-09-13 06:04:23 +08:00
dijunkun	c6635fbdc8	[feat] add Linux X11 privacy screen and automatic recovery	2026-09-13 03:49:17 +08:00
dijunkun	3c403f6162	[fix] update minirtc for SIMD and frame rate fixes	2026-09-13 02:40:44 +08:00
dijunkun	b54d32ef41	[fix] disable and uncheck hardware codec setting in unsupported builds	2026-09-13 01:40:44 +08:00
dijunkun	28e9626e0d	[fix] preserve Windows privacy startup and server window	2026-09-13 01:23:30 +08:00
kunkundi	a6e325f190	[feat] add macOS privacy screen and keep remote sessions running	2026-09-13 00:38:40 +08:00
dijunkun	23bf2ff8b8	[feat] add compact tooltips for all control bar buttons	2026-09-12 22:39:44 +08:00
dijunkun	56ebfdf8e7	[feat] add dedicated privacy screen controls	2026-09-12 22:24:09 +08:00
kunkundi	99ae0fc811	[fix] avoid false Windows privacy screen obstruction failures	2026-09-11 17:43:04 +08:00
dijunkun	9af7417c46	[feat] add Windows screen capture method setting	2026-09-11 16:41:16 +08:00
dijunkun	ceb0a1654a	[feat] add Windows privacy screen and prefer DXGI capture	2026-09-11 16:11:50 +08:00
dijunkun	4f200095f4	[fix] improve OpenGL video clarity when downscaling	2026-09-09 17:28:48 +08:00
dijunkun	bd0a7aa2f6	[fix] prevent system audio capture hangs across desktop platforms	2026-09-09 11:34:47 +08:00
dijunkun	b87ab025be	[feat] use server-issued ICE configuration across clients	2026-09-08 17:07:16 +08:00
dijunkun	5b60695a52	[fix] restore Linux Dock icons in packaged builds	2026-09-08 15:03:32 +08:00
dijunkun	0002bcea74	[fix] hide macOS Dock icon when closing to the tray	2026-09-08 00:22:08 +08:00
dijunkun	58225de7ea	[release] prepare v1.5.0 release notes and iOS version	2026-09-07 23:24:53 +08:00
dijunkun	5f37d0e753	[docs] update MiniRTC submodule documentation	2026-09-07 23:13:49 +08:00
dijunkun	b518ea82e2	[docs] refresh README screenshots and platform guides	2026-09-07 22:53:30 +08:00
dijunkun	abc8f907f3	[fix] restore iOS video after returning to the foreground	2026-09-07 21:31:08 +08:00
dijunkun	d498d3f0ef	[feat] show video resolution in the iOS floating status bar	2026-09-07 21:17:54 +08:00
dijunkun	55806d9e82	[fix] allow iOS relative mouse control outside the video area	2026-09-07 21:14:53 +08:00
dijunkun	2d3f1bb475	[fix] prevent iOS relative cursor jumps after movement	2026-09-07 21:11:27 +08:00
dijunkun	5d97d5a393	[fix] keep iOS floating controls clear of the Dynamic Island	2026-09-07 21:04:14 +08:00
dijunkun	19218a57f9	[fix] prevent stale device online status on iOS	2026-09-07 20:57:30 +08:00
dijunkun	af729144fe	[fix] prevent stale device online status	2026-09-07 20:02:19 +08:00
dijunkun	d381cbaa9b	[fix] show system tray icon on application startup	2026-09-07 17:42:25 +08:00
dijunkun	5aedb09c55	[feat] enable CUDA/OpenGL video rendering on Linux	2026-09-07 17:31:48 +08:00
dijunkun	fe1178e26f	[fix] move connection cleanup off the UI thread	2026-09-07 10:54:18 +08:00
dijunkun	e0cd761bdc	[fix] restore Windows lock-screen control and improve capture performance, fixes #98	2026-09-07 05:29:42 +08:00
dijunkun	2000654792	[fix] prevent Windows startup crashes from OpenGL failures, fixes #97	2026-09-07 04:20:54 +08:00
dijunkun	19800ef350	[fix] update MiniRTC iOS UPnP dependencies	2026-09-07 02:57:40 +08:00
dijunkun	d10b65cc19	[fix] update MiniRTC relay to P2P upgrades	2026-09-07 02:30:26 +08:00
dijunkun	3a0179968c	[fix] update MiniRTC ICE connectivity	2026-09-07 02:04:34 +08:00
dijunkun	55f389b834	[fix] update MiniRTC recovery tuning	2026-09-04 18:45:57 +08:00
dijunkun	8a58166c59	[fix] update MiniRtc video recovery timing	2026-09-04 17:35:14 +08:00
dijunkun	aa2ee8ce7f	[fix] update MiniRtc video recovery handling	2026-09-04 17:07:39 +08:00
dijunkun	b150d46501	[fix] align MiniRtc media interfaces and timestamps	2026-09-04 15:45:26 +08:00
dijunkun	010064d5b7	[feat] optimize Windows native video encoding	2026-09-04 02:23:16 +08:00
dijunkun	db3b26efe7	[feat] optimize macOS native video encoding	2026-09-04 02:06:44 +08:00
dijunkun	cd1b53ee65	[chore] standardize source file headers	2026-09-04 02:06:36 +08:00
dijunkun	b031a3953e	[feat] optimize macOS native video rendering	2026-09-04 01:28:13 +08:00
dijunkun	3f537ae63c	[feat] optimize Windows native video rendering	2026-09-03 18:01:09 +08:00
dijunkun	e716346b26	[fix] stabilize frame rate priority adaptation	2026-09-02 11:05:13 +08:00
dijunkun	b7e1adbec6	[feat] add video adaptation preference setting	2026-09-02 01:05:30 +08:00
dijunkun	58f2daa9c1	[fix] prioritize remote desktop resolution quality	2026-09-01 20:21:03 +08:00
dijunkun	8752e51921	[fix] build CI test targets separately	2026-09-01 08:33:59 +08:00
dijunkun	a8cb0e21ce	[fix] load desktop options on first configuration	2026-09-01 01:43:09 +08:00
dijunkun	90184f5251	[refactor] reorganize platform and wire sources	2026-09-01 01:29:30 +08:00
dijunkun	fb0ab4f14e	[fix] isolate iOS native build environment	2026-08-31 10:49:38 +08:00
dijunkun	0e3f3cec00	[fix] pin iOS CI xmake version	2026-08-31 10:39:36 +08:00
dijunkun	72af49eb80	[fix] use isolated iOS host build tools	2026-08-31 10:31:49 +08:00
dijunkun	36f05834b5	[fix] stabilize clean iOS dependency builds	2026-08-31 10:19:35 +08:00
dijunkun	1a190fbaf5	[fix] integrate iOS build workflow	2026-08-31 10:03:07 +08:00
dijunkun	1fe236da76	[fix] pin iOS CI package repository	2026-08-31 09:49:59 +08:00
dijunkun	3b989fb70d	[fix] set up Python for iOS CI	2026-08-31 02:20:46 +08:00
dijunkun	7595ab8bd8	[feat] add native iOS client support	2026-08-31 02:14:27 +08:00